com.sun.source.util.TaskEvent.Kind Java Examples

void test(Iterable<String> options, Iterable<JavaFileObject> files) throws IOException {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    TestListener listener = new TestListener();
    JavacTask task = tool.getTask(pw, fm, null, options, null, files);

    task.setTaskListener(listener);

    task.call();

    for (Entry<Kind, Integer> e : listener.kind2Count.entrySet()) {
        if (e.getValue() != null && e.getValue() != 0) {
            throw new IllegalStateException("Not balanced event: " + e.getKey());
        }
    }
}
 

void test(Iterable<String> options, Iterable<JavaFileObject> files) throws IOException {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    TestListener listener = new TestListener();
    JavacTask task = tool.getTask(pw, fm, null, options, null, files);

    task.setTaskListener(listener);

    task.call();

    for (Entry<Kind, Integer> e : listener.kind2Count.entrySet()) {
        if (e.getValue() != null && e.getValue() != 0) {
            throw new IllegalStateException("Not balanced event: " + e.getKey());
        }
    }
}
 

private TaskEventKind getTaskEventKind(TaskEvent.Kind kind, int totalSourceFiles, int analyzedSourceFiles) {
    if (kind == Kind.PARSE) {
        return TaskEventKind.PARSE;
    }
    else if (kind == Kind.ANALYZE) {
        if (!HAS_KIND_COMPILATION && analyzedSourceFiles >= totalSourceFiles - 1) {
            return TaskEventKind.LAST_ANALYZE;
        }
        else {
            return TaskEventKind.ANALYZE;
        }

    }
    else if (kind.name().equals("COMPILATION")) {
        return TaskEventKind.COMPILATION;
    }
    else {
        return TaskEventKind.OTHER;
    }
}
 

void test(Iterable<String> options, Iterable<JavaFileObject> files) throws IOException {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    TestListener listener = new TestListener();
    JavacTask task = tool.getTask(pw, fm, null, options, null, files);

    task.setTaskListener(listener);

    task.call();

    for (Entry<Kind, Integer> e : listener.kind2Count.entrySet()) {
        if (e.getValue() != null && e.getValue() != 0) {
            throw new IllegalStateException("Not balanced event: " + e.getKey());
        }
    }
}
 

void test(Iterable<String> options, Iterable<JavaFileObject> files) throws IOException {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    TestListener listener = new TestListener();
    JavacTask task = tool.getTask(pw, fm, null, options, null, files);

    task.setTaskListener(listener);

    task.call();

    for (Entry<Kind, Integer> e : listener.kind2Count.entrySet()) {
        if (e.getValue() != null && e.getValue() != 0) {
            throw new IllegalStateException("Not balanced event: " + e.getKey());
        }
    }
}
 

private TaskEventKind getTaskEventKind(TaskEvent.Kind kind, int totalSourceFiles, int analyzedSourceFiles) {
    if (kind == Kind.PARSE) {
        return TaskEventKind.PARSE;
    }
    else if (kind == Kind.ANALYZE) {
        if (!HAS_KIND_COMPILATION && analyzedSourceFiles >= totalSourceFiles - 1) {
            return TaskEventKind.LAST_ANALYZE;
        }
        else {
            return TaskEventKind.ANALYZE;
        }

    }
    else if (kind.name().equals("COMPILATION")) {
        return TaskEventKind.COMPILATION;
    }
    else {
        return TaskEventKind.OTHER;
    }
}
 

@Override
public void finished(TaskEvent e) {
  if (e.getKind() == Kind.ANALYZE) {
    e.getCompilationUnit().accept(new Scanner(), null);
  } else if (e.getKind() == Kind.GENERATE) {
    try {
      FileObject file =
          processingEnv
              .getFiler()
              .createResource(
                  StandardLocation.CLASS_OUTPUT, "", "output.txt", e.getTypeElement());
      try (OutputStream os = file.openOutputStream()) {
        os.write(values.toString().getBytes(UTF_8));
      }
    } catch (IOException exception) {
      throw new IOError(exception);
    }
  }
}
 

void test(Iterable<String> options, Iterable<JavaFileObject> files) throws IOException {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    TestListener listener = new TestListener();
    JavacTask task = tool.getTask(pw, fm, null, options, null, files);

    task.setTaskListener(listener);

    task.call();

    for (Entry<Kind, Integer> e : listener.kind2Count.entrySet()) {
        if (e.getValue() != null && e.getValue() != 0) {
            throw new IllegalStateException("Not balanced event: " + e.getKey());
        }
    }
}
 

private Map<String, Deps.Dependency.Kind> getEntries(Deps.Dependencies deps) {
  Map<String, Deps.Dependency.Kind> result = new LinkedHashMap<>();
  for (Dependency dep : deps.getDependencyList()) {
    result.put(dep.getPath(), dep.getKind());
  }
  return result;
}
 

/** Run Error Prone analysis after performing dataflow checks. */
@Override
public void postFlow(Env<AttrContext> env) {
  elapsed.start();
  try {
    errorProneAnalyzer.finished(new TaskEvent(Kind.ANALYZE, env.toplevel, env.enclClass.sym));
  } catch (ErrorProneError e) {
    e.logFatalError(log);
    // let the exception propagate to javac's main, where it will cause the compilation to
    // terminate with Result.ABNORMAL
    throw e;
  } finally {
    elapsed.stop();
  }
}
 

int get(Kind k) {
    Integer count = kind2Count.get(k);

    if (count == null)
        kind2Count.put(k, count = 0);

    return count;
}
 

int get(Kind k) {
    Integer count = kind2Count.get(k);

    if (count == null)
        kind2Count.put(k, count = 0);

    return count;
}
 

@Override
public Void visitClass(ClassTree node, Symtab syms) {
    Symbol sym = ((JCClassDecl)node).sym;
    if (sym != null) {
        syms.removeClass(sym.packge().modle, sym.flatName());
        Type sup = supertype(sym);
        if (isCoreClass(sym) ||
                (sup != null && isCoreClass(sup.tsym) && sup.tsym.kind != Kinds.Kind.TYP)) {
            polluted = true;
        }
    }
    return super.visitClass(node, syms);
}
 

int get(Kind k) {
    Integer count = kind2Count.get(k);

    if (count == null)
        kind2Count.put(k, count = 0);

    return count;
}
 

void test(List<String> options, List<JavaFileObject> files) throws IOException {
    System.err.println("testing: " + options + ", " + files);
    TestListener listener = new TestListener();
    JavacTask task = tool.getTask(null, fm, null, options, null, files);

    task.setTaskListener(listener);

    task.call();

    for (Entry<Kind, Integer> e : listener.kind2Count.entrySet()) {
        if (e.getValue() != null && e.getValue() != 0) {
            throw new IllegalStateException("Not balanced event: " + e.getKey());
        }
    }
}
 

@Override
public Void visitBlock(BlockTree node, Void p) {
    if (getCurrentPath().getParentPath().getLeaf().getKind() != Tree.Kind.CLASS) {
        return super.visitBlock(node, p);
    }
    Element prevOwner = currentOwner;
    try {
        currentOwner = null;
        return super.visitBlock(node, p);
    } finally {
        currentOwner = prevOwner;
    }
}
 

boolean isSimpleStringArg(JCExpression e) {
    switch (e.getTag()) {
        case LAMBDA:
            JCLambda lambda = (JCLambda)e;
            return (lambda.getBodyKind() == BodyKind.EXPRESSION) &&
                    isSimpleStringArg((JCExpression)lambda.body);
        default:
            Symbol argSym = TreeInfo.symbolFor(e);
            return (e.type.constValue() != null ||
                    (argSym != null && argSym.kind == Kinds.Kind.VAR));
    }
}
 

@Override
public void finished(TaskEvent e) {
    if (e.getKind() == Kind.ANALYZE) {
        JCCompilationUnit toplevel = (JCCompilationUnit) e.getCompilationUnit();
        if (toplevel != null && toplevel.sourcefile != null) {
            flowCompleted.add(toplevel.sourcefile.toUri());
        }
    }
}
 

private static boolean hasKindCompilation() {
    for (TaskEvent.Kind kind : TaskEvent.Kind.values()) {
        if (kind.name().equals("COMPILATION")) {
            return true;
        }
    }

    return false;
}
 

private static boolean hasKindCompilation() {
    for (TaskEvent.Kind kind : TaskEvent.Kind.values()) {
        if (kind.name().equals("COMPILATION")) {
            return true;
        }
    }

    return false;
}
 

@Override @DefinedBy(Api.COMPILER_TREE)
public Void visitClass(ClassTree node, Symtab syms) {
    Symbol sym = ((JCClassDecl)node).sym;
    if (sym != null) {
        syms.removeClass(sym.packge().modle, sym.flatName());
        Type sup = supertype(sym);
        if (isCoreClass(sym) ||
                (sup != null && isCoreClass(sup.tsym) && sup.tsym.kind != Kinds.Kind.TYP)) {
            polluted = true;
        }
    }
    return super.visitClass(node, syms);
}
 

int get(Kind k) {
    Integer count = kind2Count.get(k);

    if (count == null)
        kind2Count.put(k, count = 0);

    return count;
}
 

int get(Kind k) {
    Integer count = kind2Count.get(k);

    if (count == null)
        kind2Count.put(k, count = 0);

    return count;
}
 

int get(Kind k) {
    Integer count = kind2Count.get(k);

    if (count == null)
        kind2Count.put(k, count = 0);

    return count;
}
 

public void started(TaskEvent e) {
    if (e.getKind() != Kind.COMPILATION) {
        throw new AssertionError("Unexpected TaskListener event: " + e);
    }
}
 

@Test
public void bazelReducedSuccess() throws Exception {

  Path libD = temp.newFile("libd.jar").toPath();
  compileLib(
      libD,
      ImmutableList.<Path>of(),
      ImmutableList.of(new StringJavaFileObject("D.java", "public class D {}")));

  Path libC = temp.newFile("libc.jar").toPath();
  compileLib(
      libC,
      Collections.singleton(libD),
      ImmutableList.of(new StringJavaFileObject("C.java", "class C { static D d; }")));

  Path libB = temp.newFile("libb.jar").toPath();
  compileLib(
      libB,
      ImmutableList.of(libC, libD),
      ImmutableList.of(new StringJavaFileObject("B.java", "class B { static C c; }")));

  Path libA = temp.newFile("liba.jar").toPath();
  compileLib(
      libA,
      ImmutableList.of(libB, libC, libD),
      ImmutableList.of(new StringJavaFileObject("A.java", "class A { static B b; }")));

  optionsBuilder.addClassPathEntries(ImmutableList.of(libA.toString(), libB.toString()));
  optionsBuilder.setReducedClasspathMode(ReducedClasspathMode.BAZEL_REDUCED);
  optionsBuilder.setTargetLabel("//my:target");

  addSourceLines(
      "Hello.java",
      "class Hello {",
      "  public static A a = new A();",
      "  public static void main(String[] args) {",
      "    A a = null;",
      "    B b = null;",
      "    C c = null;",
      "    D d = null;",
      "  }",
      "}");

  optionsBuilder.addSources(ImmutableList.copyOf(Iterables.transform(sources, TO_STRING)));

  try (JavacTurbine turbine =
      new JavacTurbine(
          new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8)), true),
          optionsBuilder.build())) {
    assertThat(turbine.compile()).isEqualTo(Result.OK_WITH_REDUCED_CLASSPATH);
    Context context = turbine.context;

    JavacFileManager fm = (JavacFileManager) context.get(JavaFileManager.class);
    assertThat(fm.getLocationAsPaths(StandardLocation.CLASS_PATH)).containsExactly(libA, libB);

    Deps.Dependencies depsProto = getDeps();

    assertThat(depsProto.getSuccess()).isTrue();
    assertThat(depsProto.getRequiresReducedClasspathFallback()).isFalse();
    assertThat(depsProto.getRuleLabel()).isEqualTo("//my:target");
    assertThat(getEntries(depsProto))
        .containsExactly(
            libA.toString(),
            Deps.Dependency.Kind.EXPLICIT,
            libB.toString(),
            Deps.Dependency.Kind.INCOMPLETE);
  }
}
 

public TestSource(String fileName, String content) {
    super(URI.create("myfo:/" + fileName + ".java"), JavaFileObject.Kind.SOURCE);
    this.content = content;
}
 

@Test
public void reducedClasspathFallback() throws Exception {

  Path libD = temp.newFile("libd.jar").toPath();
  compileLib(
      libD,
      ImmutableList.<Path>of(),
      ImmutableList.of(
          new StringJavaFileObject("D.java", "public class D { static final int CONST = 42; }")));

  Path libC = temp.newFile("libc.jar").toPath();
  compileLib(
      libC,
      Collections.singleton(libD),
      ImmutableList.of(new StringJavaFileObject("C.java", "class C extends D {}")));

  Path libB = temp.newFile("libb.jar").toPath();
  compileLib(
      libB,
      ImmutableList.of(libC, libD),
      ImmutableList.of(new StringJavaFileObject("B.java", "class B extends C {}")));

  Path libA = temp.newFile("liba.jar").toPath();
  compileLib(
      libA,
      ImmutableList.of(libB, libC, libD),
      ImmutableList.of(new StringJavaFileObject("A.java", "class A extends B {}")));
  Path depsA =
      writedeps(
          "liba.jdeps",
          Deps.Dependencies.newBuilder()
              .setSuccess(true)
              .setRuleLabel("//lib:a")
              .addDependency(
                  Deps.Dependency.newBuilder()
                      .setPath(libB.toString())
                      .setKind(Deps.Dependency.Kind.EXPLICIT))
              .build());

  optionsBuilder.addClassPathEntries(
      ImmutableList.of(libA.toString(), libB.toString(), libC.toString(), libD.toString()));
  optionsBuilder.addAllDepsArtifacts(ImmutableList.of(depsA.toString()));
  optionsBuilder.addDirectJars(ImmutableList.of(libA.toString()));
  optionsBuilder.setTargetLabel("//my:target");

  addSourceLines(
      "Hello.java",
      "class Hello {",
      "  public static final int CONST = A.CONST;",
      "  public static void main(String[] args) {}",
      "}");

  optionsBuilder.addSources(ImmutableList.copyOf(Iterables.transform(sources, TO_STRING)));

  try (JavacTurbine turbine =
      new JavacTurbine(
          new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8))),
          optionsBuilder.build())) {
    assertThat(turbine.compile()).isEqualTo(Result.OK_WITH_FULL_CLASSPATH);
    Context context = turbine.context;

    JavacFileManager fm = (JavacFileManager) context.get(JavaFileManager.class);
    assertThat(fm.getLocationAsPaths(StandardLocation.CLASS_PATH))
        .containsExactly(libA, libB, libC, libD);

    Deps.Dependencies depsProto = getDeps();

    assertThat(depsProto.getSuccess()).isTrue();
    assertThat(depsProto.getRequiresReducedClasspathFallback()).isFalse();
    assertThat(depsProto.getRuleLabel()).isEqualTo("//my:target");
    assertThat(getEntries(depsProto))
        .containsExactly(
            libA.toString(), Deps.Dependency.Kind.EXPLICIT,
            libB.toString(), Deps.Dependency.Kind.IMPLICIT,
            libC.toString(), Deps.Dependency.Kind.IMPLICIT,
            libD.toString(), Deps.Dependency.Kind.IMPLICIT);
  }
}
 

@Test
public void reducedClasspath() throws Exception {

  Path libD = temp.newFile("libd.jar").toPath();
  compileLib(
      libD,
      ImmutableList.<Path>of(),
      ImmutableList.of(new StringJavaFileObject("D.java", "public class D {}")));

  Path libC = temp.newFile("libc.jar").toPath();
  compileLib(
      libC,
      Collections.singleton(libD),
      ImmutableList.of(new StringJavaFileObject("C.java", "class C { static D d; }")));

  Path libB = temp.newFile("libb.jar").toPath();
  compileLib(
      libB,
      ImmutableList.of(libC, libD),
      ImmutableList.of(new StringJavaFileObject("B.java", "class B { static C c; }")));

  Path libA = temp.newFile("liba.jar").toPath();
  compileLib(
      libA,
      ImmutableList.of(libB, libC, libD),
      ImmutableList.of(new StringJavaFileObject("A.java", "class A { static B b; }")));
  Path depsA =
      writedeps(
          "liba.jdeps",
          Deps.Dependencies.newBuilder()
              .setSuccess(true)
              .setRuleLabel("//lib:a")
              .addDependency(
                  Deps.Dependency.newBuilder()
                      .setPath(libB.toString())
                      .setKind(Deps.Dependency.Kind.EXPLICIT))
              .build());

  optionsBuilder.addClassPathEntries(
      ImmutableList.of(libA.toString(), libB.toString(), libC.toString(), libD.toString()));
  optionsBuilder.addAllDepsArtifacts(ImmutableList.of(depsA.toString()));
  optionsBuilder.addDirectJars(ImmutableList.of(libA.toString()));
  optionsBuilder.setTargetLabel("//my:target");

  addSourceLines(
      "Hello.java",
      "class Hello {",
      "  public static A a = new A();",
      "  public static void main(String[] args) {",
      "    A a = null;",
      "    B b = null;",
      "    C c = null;",
      "    D d = null;",
      "  }",
      "}");

  optionsBuilder.addSources(ImmutableList.copyOf(Iterables.transform(sources, TO_STRING)));

  try (JavacTurbine turbine =
      new JavacTurbine(
          new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err, UTF_8))),
          optionsBuilder.build())) {
    assertThat(turbine.compile())
        .isAnyOf(Result.OK_WITH_FULL_CLASSPATH, Result.OK_WITH_REDUCED_CLASSPATH);

    Context context = turbine.context;

    JavacFileManager fm = (JavacFileManager) context.get(JavaFileManager.class);
    assertThat(fm.getLocationAsPaths(StandardLocation.CLASS_PATH)).containsAtLeast(libA, libB);

    Deps.Dependencies depsProto = getDeps();

    assertThat(depsProto.getSuccess()).isTrue();
    assertThat(depsProto.getRequiresReducedClasspathFallback()).isFalse();
    assertThat(depsProto.getRuleLabel()).isEqualTo("//my:target");
    assertThat(getEntries(depsProto))
        .containsAtLeast(
            libA.toString(),
            Deps.Dependency.Kind.EXPLICIT,
            libB.toString(),
            Deps.Dependency.Kind.INCOMPLETE);
  }
}
 

StringJavaFileObject(String name, String... lines) {
  super(URI.create(name), JavaFileObject.Kind.SOURCE);
  this.content = Joiner.on('\n').join(lines);
}