--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/JCTree.java Tue Mar 15 13:48:30 2016 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/JCTree.java Thu Mar 17 19:04:28 2016 +0000
@@ -35,14 +35,20 @@
import com.sun.source.tree.*;
import com.sun.tools.javac.code.*;
+import com.sun.tools.javac.code.Directive.RequiresDirective;
import com.sun.tools.javac.code.Scope.*;
import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.DefinedBy.Api;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
import com.sun.tools.javac.util.List;
+
import static com.sun.tools.javac.tree.JCTree.Tag.*;
+import javax.tools.JavaFileManager.Location;
+
+import com.sun.tools.javac.code.Directive.ExportsDirective;
+
/**
* Root class for abstract syntax tree nodes. It provides definitions
* for specific tree nodes as subclasses nested inside.
@@ -344,6 +350,12 @@
DIV_ASG(DIV), // /=
MOD_ASG(MOD), // %=
+ MODULEDEF,
+ EXPORTS,
+ PROVIDES,
+ REQUIRES,
+ USES,
+
/** A synthetic let expression, of type LetExpr.
*/
LETEXPR; // ala scheme
@@ -484,8 +496,12 @@
public static class JCCompilationUnit extends JCTree implements CompilationUnitTree {
/** All definitions in this file (ClassDef, Import, and Skip) */
public List<JCTree> defs;
- /* The source file name. */
+ /** The source file name. */
public JavaFileObject sourcefile;
+ /** The module to which this compilation unit belongs. */
+ public ModuleSymbol modle;
+ /** The location in which this compilation unit was found. */
+ public Location locn;
/** The package to which this compilation unit belongs. */
public PackageSymbol packge;
/** A scope containing top level classes. */
@@ -2593,8 +2609,202 @@
}
}
+ public static abstract class JCDirective extends JCTree
+ implements DirectiveTree {
+ }
+
+ public static class JCModuleDecl extends JCTree implements ModuleTree {
+ public JCExpression qualId;
+ public List<JCDirective> directives;
+ public ModuleSymbol sym;
+
+ protected JCModuleDecl(JCExpression qualId, List<JCDirective> directives) {
+ this.qualId = qualId;
+ this.directives = directives;
+ }
+
+ @Override
+ public void accept(Visitor v) { v.visitModuleDef(this); }
+
+ @Override
+ public Kind getKind() {
+ return Kind.MODULE;
+ }
+
+// @Override
+ public JCExpression getName() {
+ return qualId;
+ }
+
+ @Override
+ public List<JCDirective> getDirectives() {
+ return directives;
+ }
+
+ @Override
+ public <R, D> R accept(TreeVisitor<R, D> v, D d) {
+ return v.visitModule(this, d);
+ }
+
+ @Override
+ public Tag getTag() {
+ return MODULEDEF;
+ }
+ }
+
+ public static class JCExports extends JCDirective
+ implements ExportsTree {
+ public JCExpression qualid;
+ public List<JCExpression> moduleNames;
+ public ExportsDirective directive;
+
+ protected JCExports(JCExpression qualId, List<JCExpression> moduleNames) {
+ this.qualid = qualId;
+ this.moduleNames = moduleNames;
+ }
+
+ @Override
+ public void accept(Visitor v) { v.visitExports(this); }
+
+ @Override
+ public Kind getKind() {
+ return Kind.EXPORTS;
+ }
+
+ @Override
+ public JCExpression getExportName() {
+ return qualid;
+ }
+
+ @Override
+ public List<JCExpression> getModuleNames() {
+ return moduleNames;
+ }
+
+ @Override
+ public <R, D> R accept(TreeVisitor<R, D> v, D d) {
+ return v.visitExports(this, d);
+ }
+
+ @Override
+ public Tag getTag() {
+ return EXPORTS;
+ }
+ }
+
+ public static class JCProvides extends JCDirective
+ implements ProvidesTree {
+ public JCExpression serviceName;
+ public JCExpression implName;
+
+ protected JCProvides(JCExpression serviceName, JCExpression implName) {
+ this.serviceName = serviceName;
+ this.implName = implName;
+ }
+
+ @Override
+ public void accept(Visitor v) { v.visitProvides(this); }
+
+ @Override
+ public Kind getKind() {
+ return Kind.PROVIDES;
+ }
+
+ @Override
+ public <R, D> R accept(TreeVisitor<R, D> v, D d) {
+ return v.visitProvides(this, d);
+ }
+
+ @Override
+ public JCExpression getServiceName() {
+ return serviceName;
+ }
+
+ @Override
+ public JCExpression getImplementationName() {
+ return implName;
+ }
+
+ @Override
+ public Tag getTag() {
+ return PROVIDES;
+ }
+ }
+
+ public static class JCRequires extends JCDirective
+ implements RequiresTree {
+ public boolean isPublic;
+ public JCExpression moduleName;
+ public RequiresDirective directive;
+
+ protected JCRequires(boolean isPublic, JCExpression moduleName) {
+ this.isPublic = isPublic;
+ this.moduleName = moduleName;
+ }
+
+ @Override
+ public void accept(Visitor v) { v.visitRequires(this); }
+
+ @Override
+ public Kind getKind() {
+ return Kind.REQUIRES;
+ }
+
+ @Override
+ public <R, D> R accept(TreeVisitor<R, D> v, D d) {
+ return v.visitRequires(this, d);
+ }
+
+ @Override
+ public boolean isPublic() {
+ return isPublic;
+ }
+
+ @Override
+ public JCExpression getModuleName() {
+ return moduleName;
+ }
+
+ @Override
+ public Tag getTag() {
+ return REQUIRES;
+ }
+ }
+
+ public static class JCUses extends JCDirective
+ implements UsesTree {
+ public JCExpression qualid;
+
+ protected JCUses(JCExpression qualId) {
+ this.qualid = qualId;
+ }
+
+ @Override
+ public void accept(Visitor v) { v.visitUses(this); }
+
+ @Override
+ public Kind getKind() {
+ return Kind.USES;
+ }
+
+ @Override
+ public JCExpression getServiceName() {
+ return qualid;
+ }
+
+ @Override
+ public <R, D> R accept(TreeVisitor<R, D> v, D d) {
+ return v.visitUses(this, d);
+ }
+
+ @Override
+ public Tag getTag() {
+ return USES;
+ }
+ }
+
public static class JCErroneous extends JCExpression
- implements com.sun.source.tree.ErroneousTree {
+ implements ErroneousTree {
public List<? extends JCTree> errs;
protected JCErroneous(List<? extends JCTree> errs) {
this.errs = errs;
@@ -2731,6 +2941,11 @@
JCAnnotation Annotation(JCTree annotationType, List<JCExpression> args);
JCModifiers Modifiers(long flags, List<JCAnnotation> annotations);
JCErroneous Erroneous(List<? extends JCTree> errs);
+ JCModuleDecl ModuleDef(JCExpression qualId, List<JCDirective> directives);
+ JCExports Exports(JCExpression qualId, List<JCExpression> moduleNames);
+ JCProvides Provides(JCExpression serviceName, JCExpression implName);
+ JCRequires Requires(boolean isPublic, JCExpression qualId);
+ JCUses Uses(JCExpression qualId);
LetExpr LetExpr(List<JCVariableDecl> defs, JCExpression expr);
}
@@ -2791,6 +3006,11 @@
public void visitModifiers(JCModifiers that) { visitTree(that); }
public void visitAnnotatedType(JCAnnotatedType that) { visitTree(that); }
public void visitErroneous(JCErroneous that) { visitTree(that); }
+ public void visitModuleDef(JCModuleDecl that) { visitTree(that); }
+ public void visitExports(JCExports that) { visitTree(that); }
+ public void visitProvides(JCProvides that) { visitTree(that); }
+ public void visitRequires(JCRequires that) { visitTree(that); }
+ public void visitUses(JCUses that) { visitTree(that); }
public void visitLetExpr(LetExpr that) { visitTree(that); }
public void visitTree(JCTree that) { Assert.error(); }