jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/tree/JCTree.java

-:475eb15dfdad
+:f91144b7da75
 /*
-* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 /** Parameterized types, of type TypeApply.
 */
 TYPEAPPLY,
-/** Union types, of type TypeUnion
+/** Union types, of type TypeUnion.
 */
 TYPEUNION,
-/** Intersection types, of type TypeIntersection
+/** Intersection types, of type TypeIntersection.
 */
 TYPEINTERSECTION,
 /** Formal type parameters, of type TypeParameter.
 */
 /** metadata: Annotation.
 */
 ANNOTATION,
+/** metadata: Type annotation.
+*/
+TYPE_ANNOTATION,
 /** metadata: Modifiers
 */
 MODIFIERS,
+/** An annotated type tree.
+*/
 ANNOTATED_TYPE,
 /** Error trees, of type Erroneous.
 */
 ERRONEOUS,
 return this;
 }
 }
 /**
+* Common supertype for all poly expression trees (lambda, method references,
+* conditionals, method and constructor calls)
+*/
+public static abstract class JCPolyExpression extends JCExpression {
+/**
+* A poly expression can only be truly 'poly' in certain contexts
+*/
+public enum PolyKind {
+/** poly expression to be treated as a standalone expression */
+STANDALONE,
+/** true poly expression */
+POLY;
+}
+/** is this poly expression a 'true' poly expression? */
+public PolyKind polyKind;
+}
+/**
+* Common supertype for all functional expression trees (lambda and method references)
+*/
+public static abstract class JCFunctionalExpression extends JCPolyExpression {
+public JCFunctionalExpression() {
+//a functional expression is always a 'true' poly
+polyKind = PolyKind.POLY;
+}
+/** target descriptor inferred for this functional expression. */
+public Type descriptorType;
+/** list of target types inferred for this functional expression. */
+public List<TypeSymbol> targets;
+}
+/**
 * A class definition.
 */
 public static class JCClassDecl extends JCStatement implements ClassTree {
 /** the modifiers */
 public JCModifiers mods;
 public Name name;
 /** type of method return value */
 public JCExpression restype;
 /** type parameters */
 public List<JCTypeParameter> typarams;
+/** receiver parameter */
+public JCVariableDecl recvparam;
 /** value parameters */
 public List<JCVariableDecl> params;
 /** exceptions thrown by this method */
 public List<JCExpression> thrown;
 /** statements in the method */
 public MethodSymbol sym;
 protected JCMethodDecl(JCModifiers mods,
 Name name,
 JCExpression restype,
 List<JCTypeParameter> typarams,
+JCVariableDecl recvparam,
 List<JCVariableDecl> params,
 List<JCExpression> thrown,
 JCBlock body,
 JCExpression defaultValue,
 MethodSymbol sym)
 this.mods = mods;
 this.name = name;
 this.restype = restype;
 this.typarams = typarams;
 this.params = params;
+this.recvparam = recvparam;
+// TODO: do something special if the given type is null?
+// receiver != null ? receiver : List.<JCTypeAnnotation>nil());
 this.thrown = thrown;
 this.body = body;
 this.defaultValue = defaultValue;
 this.sym = sym;
 }
 return typarams;
 }
 public List<JCVariableDecl> getParameters() {
 return params;
 }
+public JCVariableDecl getReceiverParameter() { return recvparam; }
 public List<JCExpression> getThrows() {
 return thrown;
 }
 public JCBlock getBody() { return body; }
 public JCTree getDefaultValue() { // for annotation types
 }
 /**
 * A ( ) ? ( ) : ( ) conditional expression
 */
-public static class JCConditional extends JCExpression implements ConditionalExpressionTree {
+public static class JCConditional extends JCPolyExpression implements ConditionalExpressionTree {
 public JCExpression cond;
 public JCExpression truepart;
 public JCExpression falsepart;
 protected JCConditional(JCExpression cond,
 JCExpression truepart,
 }
 /**
 * A method invocation
 */
-public static class JCMethodInvocation extends JCExpression implements MethodInvocationTree {
+public static class JCMethodInvocation extends JCPolyExpression implements MethodInvocationTree {
 public List<JCExpression> typeargs;
 public JCExpression meth;
 public List<JCExpression> args;
 public Type varargsElement;
 protected JCMethodInvocation(List<JCExpression> typeargs,
 }
 /**
 * A new(...) operation.
 */
-public static class JCNewClass extends JCExpression implements NewClassTree {
+public static class JCNewClass extends JCPolyExpression implements NewClassTree {
 public JCExpression encl;
 public List<JCExpression> typeargs;
 public JCExpression clazz;
 public List<JCExpression> args;
 public JCClassDecl def;
 * A new[...] operation.
 */
 public static class JCNewArray extends JCExpression implements NewArrayTree {
 public JCExpression elemtype;
 public List<JCExpression> dims;
+// type annotations on inner-most component
+public List<JCAnnotation> annotations;
+// type annotations on dimensions
+public List<List<JCAnnotation>> dimAnnotations;
 public List<JCExpression> elems;
 protected JCNewArray(JCExpression elemtype,
 List<JCExpression> dims,
 List<JCExpression> elems)
 {
 this.elemtype = elemtype;
 this.dims = dims;
+this.annotations = List.nil();
+this.dimAnnotations = List.nil();
 this.elems = elems;
 }
 @Override
 public void accept(Visitor v) { v.visitNewArray(this); }
 }
 /**
 * A lambda expression.
 */
-public static class JCLambda extends JCExpression implements LambdaExpressionTree {
+public static class JCLambda extends JCFunctionalExpression implements LambdaExpressionTree {
+public enum ParameterKind {
+IMPLICIT,
+EXPLICIT;
+}
 public List<JCVariableDecl> params;
 public JCTree body;
-public Type targetType;
 public boolean canCompleteNormally = true;
 public List<Type> inferredThrownTypes;
+public ParameterKind paramKind;
 public JCLambda(List<JCVariableDecl> params,
 JCTree body) {
 this.params = params;
 this.body = body;
+if (params.isEmpty() ||
+params.head.vartype != null) {
+paramKind = ParameterKind.EXPLICIT;
+} else {
+paramKind = ParameterKind.IMPLICIT;
+}
 }
 @Override
 public Tag getTag() {
 return LAMBDA;
 }
 }
 /**
 * Selects a member expression.
 */
-public static class JCMemberReference extends JCExpression implements MemberReferenceTree {
+public static class JCMemberReference extends JCFunctionalExpression implements MemberReferenceTree {
 public ReferenceMode mode;
 public ReferenceKind kind;
 public Name name;
 public JCExpression expr;
 public List<JCExpression> typeargs;
-public Type targetType;
 public Symbol sym;
 public Type varargsElement;
+public PolyKind refPolyKind;
 /**
 * Javac-dependent classification for member references, based
 * on relevant properties w.r.t. code-generation
 */
 /** Expr # instMethod */
 BOUND(ReferenceMode.INVOKE, false),
 /** Inner # new */
 IMPLICIT_INNER(ReferenceMode.NEW, false),
 /** Toplevel # new */
-TOPLEVEL(ReferenceMode.NEW, false);
+TOPLEVEL(ReferenceMode.NEW, false),
+/** ArrayType # new */
+ARRAY_CTOR(ReferenceMode.NEW, false);
 final ReferenceMode mode;
 final boolean unbound;
 private ReferenceKind(ReferenceMode mode, boolean unbound) {
 public static class JCTypeParameter extends JCTree implements TypeParameterTree {
 /** name */
 public Name name;
 /** bounds */
 public List<JCExpression> bounds;
-protected JCTypeParameter(Name name, List<JCExpression> bounds) {
+/** type annotations on type parameter */
+public List<JCAnnotation> annotations;
+protected JCTypeParameter(Name name, List<JCExpression> bounds, List<JCAnnotation> annotations) {
 this.name = name;
 this.bounds = bounds;
+this.annotations = annotations;
 }
 @Override
 public void accept(Visitor v) { v.visitTypeParameter(this); }
 public Kind getKind() { return Kind.TYPE_PARAMETER; }
 public Name getName() { return name; }
 public List<JCExpression> getBounds() {
 return bounds;
+}
+public List<JCAnnotation> getAnnotations() {
+return annotations;
 }
 @Override
 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
 return v.visitTypeParameter(this, d);
 }
 return TYPEBOUNDKIND;
 }
 }
 public static class JCAnnotation extends JCExpression implements AnnotationTree {
+// Either Tag.ANNOTATION or Tag.TYPE_ANNOTATION
+private Tag tag;
 public JCTree annotationType;
 public List<JCExpression> args;
-protected JCAnnotation(JCTree annotationType, List<JCExpression> args) {
+// Attribute.Compound if tag is ANNOTATION
+// Attribute.TypeCompound if tag is TYPE_ANNOTATION
+public Attribute.Compound attribute;
+protected JCAnnotation(Tag tag, JCTree annotationType, List<JCExpression> args) {
+this.tag = tag;
 this.annotationType = annotationType;
 this.args = args;
 }
 @Override
 public void accept(Visitor v) { v.visitAnnotation(this); }
-public Kind getKind() { return Kind.ANNOTATION; }
+public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
 public JCTree getAnnotationType() { return annotationType; }
 public List<JCExpression> getArguments() {
 return args;
 }
 @Override
 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
 return v.visitAnnotation(this, d);
 }
 @Override
 public Tag getTag() {
-return ANNOTATION;
+return tag;
 }
 }
 public static class JCModifiers extends JCTree implements com.sun.source.tree.ModifiersTree {
 public long flags;
 return v.visitModifiers(this, d);
 }
 @Override
 public Tag getTag() {
 return MODIFIERS;
+}
+}
+public static class JCAnnotatedType extends JCExpression implements com.sun.source.tree.AnnotatedTypeTree {
+// type annotations
+public List<JCAnnotation> annotations;
+public JCExpression underlyingType;
+protected JCAnnotatedType(List<JCAnnotation> annotations, JCExpression underlyingType) {
+this.annotations = annotations;
+this.underlyingType = underlyingType;
+}
+@Override
+public void accept(Visitor v) { v.visitAnnotatedType(this); }
+public Kind getKind() { return Kind.ANNOTATED_TYPE; }
+public List<JCAnnotation> getAnnotations() {
+return annotations;
+}
+public JCExpression getUnderlyingType() {
+return underlyingType;
+}
+@Override
+public <R,D> R accept(TreeVisitor<R,D> v, D d) {
+return v.visitAnnotatedType(this, d);
+}
+@Override
+public Tag getTag() {
+return ANNOTATED_TYPE;
 }
 }
 public static class JCErroneous extends JCExpression
 implements com.sun.source.tree.ErroneousTree {
 List<JCTree> defs);
 JCMethodDecl MethodDef(JCModifiers mods,
 Name name,
 JCExpression restype,
 List<JCTypeParameter> typarams,
+JCVariableDecl recvparam,
 List<JCVariableDecl> params,
 List<JCExpression> thrown,
 JCBlock body,
 JCExpression defaultValue);
 JCVariableDecl VarDef(JCModifiers mods,
 public void visitTypeParameter(JCTypeParameter that) { visitTree(that); }
 public void visitWildcard(JCWildcard that)           { visitTree(that); }
 public void visitTypeBoundKind(TypeBoundKind that)   { visitTree(that); }
 public void visitAnnotation(JCAnnotation that)       { visitTree(that); }
 public void visitModifiers(JCModifiers that)         { visitTree(that); }
+public void visitAnnotatedType(JCAnnotatedType that) { visitTree(that); }
 public void visitErroneous(JCErroneous that)         { visitTree(that); }
 public void visitLetExpr(LetExpr that)               { visitTree(that); }
 public void visitTree(JCTree that)                   { Assert.error(); }
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/tree/JCTree.java

src/share/classes/com/sun/tools/javac/tree/JCTree.java