Java Snippet类代码示例

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardSingleImportMethodToClass1() {
    Snippet a = classKey(assertEval("class A { String s = format(\"%d\", 10); }",
            added(RECOVERABLE_DEFINED)));
    assertEvalUnresolvedException("new A();", "A", 1, 0);
    assertEval("import static java.lang.String.format;",
            added(VALID),
            ste(a, RECOVERABLE_DEFINED, VALID, false, null));
    assertEval("new A().s;", "\"10\"");
    Snippet format = methodKey(assertEval("void format(String s, int d) { }",
            DiagCheck.DIAG_OK,
            DiagCheck.DIAG_ERROR,
            added(VALID),
            ste(a, VALID, RECOVERABLE_DEFINED, false, MAIN_SNIPPET)));
    assertEvalUnresolvedException("new A();", "A", 0, 1);
    assertActiveKeys();
    assertDrop(format,
            ste(format, VALID, DROPPED, true, null),
            ste(a, RECOVERABLE_DEFINED, VALID, false, format));
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
/**
 * Convert user arguments to a Stream of snippets referenced by those
 * arguments.
 *
 * @param snippetSupplier the base list of possible snippets
 * @param args the user's argument to the command, maybe be the empty list
 * @return a Stream of referenced snippets or null if no matches to specific
 * arg
 */
private <T extends Snippet> Stream<T> argsToSnippets(Supplier<Stream<T>> snippetSupplier,
        List<String> args) {
    Stream<T> result = null;
    for (String arg : args) {
        // Find the best match
        Stream<T> st = layeredSnippetSearch(snippetSupplier, arg);
        if (st == null) {
            Stream<Snippet> est = layeredSnippetSearch(state::snippets, arg);
            if (est == null) {
                errormsg("jshell.err.no.such.snippets", arg);
            } else {
                errormsg("jshell.err.the.snippet.cannot.be.used.with.this.command",
                        arg, est.findFirst().get().source());
            }
            return null;
        }
        if (result == null) {
            result = st;
        } else {
            result = Stream.concat(result, st);
        }
    }
    return result;
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardImportOnDemandMethodToClass2() {
    Snippet a = classKey(assertEval("class A { String s() { return format(\"%d\", 10); } }",
            added(RECOVERABLE_DEFINED)));
    assertEvalUnresolvedException("new A();", "A", 1, 0);
    assertEval("import static java.lang.String.*;",
            added(VALID),
            ste(a, RECOVERABLE_DEFINED, VALID, false, null));
    assertEval("new A().s();", "\"10\"");
    Snippet format = methodKey(assertEval("void format(String s, int d) { }",
            DiagCheck.DIAG_OK,
            DiagCheck.DIAG_ERROR,
            added(VALID),
            ste(a, VALID, RECOVERABLE_DEFINED, false, null)));
    assertEvalUnresolvedException("new A();", "A", 0, 1);
    assertActiveKeys();
    assertDrop(format,
            ste(format, VALID, DROPPED, true, null),
            ste(a, RECOVERABLE_DEFINED, VALID, false, format));
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardImportOnDemandClassToClass1() {
    Snippet a = classKey(assertEval("class A { static List<Integer> list; }",
            added(RECOVERABLE_NOT_DEFINED)));
    assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
    assertEval("import java.util.*;",
            added(VALID),
            ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
    assertEval("A.list = Arrays.asList(1, 2, 3);", "[1, 2, 3]");

    Snippet list = classKey(assertEval("class List {}",
            DiagCheck.DIAG_OK,
            DiagCheck.DIAG_ERROR,
            added(VALID),
            ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
    assertDeclareFail("A.list = Arrays.asList(1, 2, 3);", "compiler.err.cant.resolve.location");
    assertActiveKeys();
    assertDrop(list,
            ste(list, VALID, DROPPED, true, null),
            ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, list));
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
@Override
public void accept(SnippetEvent t) {
    Snippet snip = t.snippet();
    Snippet.Status stat = t.status();
    if (session == null) {
        return;
    }
    if (stat == Snippet.Status.DROPPED ||
        stat == Snippet.Status.OVERWRITTEN) {
        SnippetHandle h = session.getSnippetRegistry().getHandle(snip);
        if (h != null) {
            N n = factory.findNode(h);
            if (n != null) {
                n.fireDisplayNameChange();
            }
        }
    }
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardSingleImportClassToClass1() {
    Snippet a = classKey(assertEval("class A { static List<Integer> list; }",
            added(RECOVERABLE_NOT_DEFINED)));
    assertDeclareFail("new A();", "compiler.err.cant.resolve.location");
    assertEval("import java.util.List;",
            added(VALID),
            ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null));
    assertEval("import java.util.Arrays;", added(VALID));
    assertEval("A.list = Arrays.asList(1, 2, 3);", "[1, 2, 3]");

    Snippet list = classKey(assertEval("class List {}",
            DiagCheck.DIAG_OK,
            DiagCheck.DIAG_ERROR,
            added(VALID),
            ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, null)));
    assertDeclareFail("A.list = Arrays.asList(1, 2, 3);", "compiler.err.already.defined.static.single.import");
    assertActiveKeys();
    assertDrop(list,
            ste(list, VALID, DROPPED, true, null),
            ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, list));
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
@Override
public void snippetChange(SnippetEvent ev) {
    Snippet snip = ev.snippet();
    Status stat = ev.status();
    Rng snipRange = getInputRange();

    switch (stat) {
        case VALID:
        case RECOVERABLE_DEFINED:
        case RECOVERABLE_NOT_DEFINED: {
            SnippetData data = new SnippetData(snip);
            data.setRange(snipRange);
            snippetData.put(snip, data);
            break;
        }
            
        case DROPPED:
        case OVERWRITTEN: 
        // rejected, but still may be a part of the parsing, unless replaced
        case REJECTED:
            break;
    }
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardImportOnDemandFieldToClass2() {
    Snippet a = classKey(assertEval("class A { static double pi = PI; }",
            added(RECOVERABLE_DEFINED)));
    assertEvalUnresolvedException("new A();", "A", 1, 0);
    assertEval("import static java.lang.Math.*;",
            added(VALID),
            ste(a, RECOVERABLE_DEFINED, VALID, true, null));
    assertEval("Math.abs(A.pi - 3.1415) < 0.001;", "true");

    Snippet list = varKey(assertEval("String PI;",
            DiagCheck.DIAG_OK,
            DiagCheck.DIAG_ERROR,
            added(VALID),
            ste(a, VALID, RECOVERABLE_DEFINED, true, null)));
    assertEvalUnresolvedException("new A();", "A", 0, 1);
    assertActiveKeys();
    assertDrop(list,
            ste(list, VALID, DROPPED, true, null),
            ste(a, RECOVERABLE_DEFINED, VALID, true, list));
    assertEval("Math.abs(A.pi - 3.1415) < 0.001;", "true");
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testMethods() {
    assertEval("interface Interface {" +
            "default int defaultMethod() { return 0; }" +
            "static int staticMethod() { return 0; }" +
            "}");
    Snippet clazz = classKey(assertEval("class Clazz {" +
            "static int staticMethod() { return 0; }" +
            "int method() { return 0; }" +
            "}"));
    assertCompletion("Interface.staticMeth|", "staticMethod()");
    assertCompletion("Clazz.staticMeth|", "staticMethod()");
    assertCompletion("new Interface() {}.defaultMe||", "defaultMethod()");
    assertCompletion("new Clazz().staticMeth|");
    assertCompletion("new Clazz().meth|", "method()");
    assertEval("class Clazz implements Interface {}",
            ste(MAIN_SNIPPET, VALID, VALID, true, null),
            ste(clazz, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
    assertCompletion("Clazz.staticMeth|");
    assertCompletion("new Clazz() {}.defaultM|", "defaultMethod()");
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public static Key create(Snippet snip) {
    switch (snip.kind()) {
        case IMPORT: 
            ImportSnippet imp = ((ImportSnippet)snip);
            return new Key("I_" + imp.fullname() + (imp.isStatic() ? "*" : ""));
        case TYPE_DECL:
            TypeDeclSnippet tdecl = ((TypeDeclSnippet)snip);
            return new Key("T_" + tdecl.name());
        case METHOD:
            MethodSnippet method = ((MethodSnippet)snip);
            return new Key("M_" + method.name() + ":" + method.signature());
        case VAR:
            VarSnippet var = (VarSnippet)snip;
            return new Key("V_" + var.name() + ":" + var.typeName());
        case EXPRESSION:
            ExpressionSnippet expr = (ExpressionSnippet)snip;
            return new Key("E_" + (expr.name()) + ":" + (expr.typeName()));
        case STATEMENT:
        case ERRONEOUS:
            return new Key("C_" + snip.source());
        default:
            throw new AssertionError(snip.kind().name());
    }
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardClassToClass3() {
    Snippet a = classKey(assertEval("interface A extends B { static int f() { return 10; } }", added(RECOVERABLE_NOT_DEFINED)));
    assertDeclareFail("A.f();", "compiler.err.cant.resolve.location");

    Snippet b = classKey(assertEval("interface B { }",
            added(VALID),
            ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null)));
    assertEval("A.f();", "10");
    assertEval("class B { }",
            DiagCheck.DIAG_OK,
            DiagCheck.DIAG_ERROR,
            ste(MAIN_SNIPPET, VALID, VALID, true, null),
            ste(b, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
            ste(a, VALID, RECOVERABLE_NOT_DEFINED, true, MAIN_SNIPPET));
    assertDeclareFail("A.f();", "compiler.err.cant.resolve.location");
    assertActiveKeys();
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardClassToClass1() {
    Snippet a = classKey(assertEval("class A { B b = new B(); }", added(RECOVERABLE_NOT_DEFINED)));
    assertDeclareFail("new A().b;", "compiler.err.cant.resolve.location");

    Snippet b = classKey(assertEval("class B { public String toString() { return \"B\"; } }",
            added(VALID),
            ste(a, RECOVERABLE_NOT_DEFINED, VALID, true, null)));
    assertEval("new A().b;", "B");
    assertEval("interface B { }",
            DiagCheck.DIAG_OK,
            DiagCheck.DIAG_ERROR,
            ste(MAIN_SNIPPET, VALID, VALID, true, null),
            ste(b, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
            ste(a, VALID, RECOVERABLE_DEFINED, true, MAIN_SNIPPET));
    assertEvalUnresolvedException("new A().b;", "A", 0, 1);
    assertActiveKeys();
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void classesCyclic1() {
    Snippet b = classKey(assertEval("class B extends A { }",
            added(RECOVERABLE_NOT_DEFINED)));
    Snippet a = classKey(assertEval("class A extends B { }", DiagCheck.DIAG_IGNORE, DiagCheck.DIAG_IGNORE,
            added(REJECTED)));
    /***
    assertDeclareFail("class A extends B { }", "****",
            added(REJECTED),
            ste(b, RECOVERABLE_NOT_DEFINED, RECOVERABLE_NOT_DEFINED, false, MAIN_SNIPPET));
    ***/
    // It is random which one it shows up in, but cyclic error should be there
    List<Diag> diagsA = getState().diagnostics(a).collect(toList());
    List<Diag> diagsB = getState().diagnostics(b).collect(toList());
    List<Diag> diags;
    if (diagsA.isEmpty()) {
        diags = diagsB;
    } else {
        diags = diagsA;
        assertTrue(diagsB.isEmpty());
    }
    assertEquals(diags.size(), 1, "Expected one error");
    assertEquals(diags.get(0).getCode(), "compiler.err.cyclic.inheritance", "Expected cyclic inheritance error");
    assertActiveKeys();
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardMethodToMethod() {
    Snippet t = methodKey(assertEval("int t() { return f(); }", added(RECOVERABLE_DEFINED)));
    Snippet f = methodKey(assertEval("int f() { return g(); }",
            added(RECOVERABLE_DEFINED),
            ste(t, RECOVERABLE_DEFINED, VALID, false, null)));
    assertUnresolvedDependencies1((DeclarationSnippet) f, RECOVERABLE_DEFINED, "method g()");
    assertEvalUnresolvedException("t();", "f", 1, 0);
    Snippet g = methodKey(assertEval("int g() { return 55; }",
            added(VALID),
            ste(f, RECOVERABLE_DEFINED, VALID, false, null)));
    assertEval("t();", "55");
    assertEval("double g() { return 3.14159; }",
            DiagCheck.DIAG_OK,
            DiagCheck.DIAG_ERROR,
            ste(MAIN_SNIPPET, VALID, VALID, true, null),
            ste(g, VALID, OVERWRITTEN, false, MAIN_SNIPPET),
            ste(f, VALID, RECOVERABLE_DEFINED, false, MAIN_SNIPPET));
    DeclarationSnippet exsn = assertEvalUnresolvedException("t();", "f", 0, 1);
    assertTrue(exsn == f, "Identity must not change");
    assertActiveKeys();
}
 

import jdk.jshell.Snippet; //导入依赖的package包/类
public void testForwardVarToClassGeneric() {
    DeclarationSnippet a = classKey(assertEval("class A<T> { final T x; A(T v) { this.x = v; } ; T get() { return x; } int core() { return g; } }", added(RECOVERABLE_DEFINED)));
    assertUnresolvedDependencies1(a, RECOVERABLE_DEFINED, "variable g");

    List<SnippetEvent> events = assertEval("A<String> as = new A<>(\"hi\");", null,
            UnresolvedReferenceException.class, DiagCheck.DIAG_OK, DiagCheck.DIAG_OK, null);
    SnippetEvent ste = events.get(0);
    Snippet assn = ste.snippet();
    DeclarationSnippet unsn = ((UnresolvedReferenceException) ste.exception()).getSnippet();
    assertEquals(unsn.name(), "A", "Wrong with unresolved");
    assertEquals(getState().unresolvedDependencies(unsn).count(), 1, "Wrong size unresolved");
    assertEquals(getState().diagnostics(unsn).count(), 0L, "Expected no diagnostics");

    Snippet g = varKey(assertEval("int g = 10;", "10",
            added(VALID),
            ste(a, RECOVERABLE_DEFINED, VALID, false, MAIN_SNIPPET)));
    assertEval("A<String> as = new A<>(\"low\");",
            ste(MAIN_SNIPPET, VALID, VALID, false, null),
            ste(assn, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
    assertEval("as.get();", "\"low\"");
    assertUnresolvedDependencies(a, 0);
    assertActiveKeys();
}