jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/tree/TreeMaker.java@4851ff2ffc10

     1 /*

     2  * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    26 package com.sun.tools.javac.tree;

    28 import com.sun.tools.javac.code.*;

    29 import com.sun.tools.javac.code.Symbol.*;

    30 import com.sun.tools.javac.code.Type.*;

    31 import com.sun.tools.javac.util.*;

    32 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

    34 import com.sun.tools.javac.tree.JCTree.*;

    36 import static com.sun.tools.javac.code.Flags.*;

    37 import static com.sun.tools.javac.code.Kinds.*;

    38 import static com.sun.tools.javac.code.TypeTags.*;

    40 /** Factory class for trees.

    41  *

    42  *  <p><b>This is NOT part of any supported API.

    43  *  If you write code that depends on this, you do so at your own risk.

    44  *  This code and its internal interfaces are subject to change or

    45  *  deletion without notice.</b>

    46  */

    47 public class TreeMaker implements JCTree.Factory {

    49     /** The context key for the tree factory. */

    50     protected static final Context.Key<TreeMaker> treeMakerKey =

    51         new Context.Key<TreeMaker>();

    53     /** Get the TreeMaker instance. */

    54     public static TreeMaker instance(Context context) {

    55         TreeMaker instance = context.get(treeMakerKey);

    56         if (instance == null)

    57             instance = new TreeMaker(context);

    58         return instance;

    59     }

    61     /** The position at which subsequent trees will be created.

    62      */

    63     public int pos = Position.NOPOS;

    65     /** The toplevel tree to which created trees belong.

    66      */

    67     public JCCompilationUnit toplevel;

    69     /** The current name table. */

    70     Names names;

    72     Types types;

    74     /** The current symbol table. */

    75     Symtab syms;

    77     /** Create a tree maker with null toplevel and NOPOS as initial position.

    78      */

    79     protected TreeMaker(Context context) {

    80         context.put(treeMakerKey, this);

    81         this.pos = Position.NOPOS;

    82         this.toplevel = null;

    83         this.names = Names.instance(context);

    84         this.syms = Symtab.instance(context);

    85         this.types = Types.instance(context);

    86     }

    88     /** Create a tree maker with a given toplevel and FIRSTPOS as initial position.

    89      */

    90     TreeMaker(JCCompilationUnit toplevel, Names names, Types types, Symtab syms) {

    91         this.pos = Position.FIRSTPOS;

    92         this.toplevel = toplevel;

    93         this.names = names;

    94         this.types = types;

    95         this.syms = syms;

    96     }

    98     /** Create a new tree maker for a given toplevel.

    99      */

   100     public TreeMaker forToplevel(JCCompilationUnit toplevel) {

   101         return new TreeMaker(toplevel, names, types, syms);

   102     }

   104     /** Reassign current position.

   105      */

   106     public TreeMaker at(int pos) {

   107         this.pos = pos;

   108         return this;

   109     }

   111     /** Reassign current position.

   112      */

   113     public TreeMaker at(DiagnosticPosition pos) {

   114         this.pos = (pos == null ? Position.NOPOS : pos.getStartPosition());

   115         return this;

   116     }

   118     /**

   119      * Create given tree node at current position.

   120      * @param defs a list of ClassDef, Import, and Skip

   121      */

   122     public JCCompilationUnit TopLevel(List<JCAnnotation> packageAnnotations,

   123                                       JCExpression pid,

   124                                       List<JCTree> defs) {

   125         assert packageAnnotations != null;

   126         for (JCTree node : defs)

   127             assert node instanceof JCClassDecl

   128                 || node instanceof JCImport

   129                 || node instanceof JCSkip

   130                 || node instanceof JCErroneous

   131                 || (node instanceof JCExpressionStatement

   132                     && ((JCExpressionStatement)node).expr instanceof JCErroneous)

   133                  : node.getClass().getSimpleName();

   134         JCCompilationUnit tree = new JCCompilationUnit(packageAnnotations, pid, defs,

   135                                      null, null, null, null);

   136         tree.pos = pos;

   137         return tree;

   138     }

   140     public JCImport Import(JCTree qualid, boolean importStatic) {

   141         JCImport tree = new JCImport(qualid, importStatic);

   142         tree.pos = pos;

   143         return tree;

   144     }

   146     public JCClassDecl ClassDef(JCModifiers mods,

   147                                 Name name,

   148                                 List<JCTypeParameter> typarams,

   149                                 JCTree extending,

   150                                 List<JCExpression> implementing,

   151                                 List<JCTree> defs)

   152     {

   153         JCClassDecl tree = new JCClassDecl(mods,

   154                                      name,

   155                                      typarams,

   156                                      extending,

   157                                      implementing,

   158                                      defs,

   159                                      null);

   160         tree.pos = pos;

   161         return tree;

   162     }

   164     public JCMethodDecl MethodDef(JCModifiers mods,

   165                                Name name,

   166                                JCExpression restype,

   167                                List<JCTypeParameter> typarams,

   168                                List<JCVariableDecl> params,

   169                                List<JCExpression> thrown,

   170                                JCBlock body,

   171                                JCExpression defaultValue) {

   172         return MethodDef(

   173                 mods, name, restype, typarams, params,

   174                 null, thrown, body, defaultValue);

   175     }

   177     public JCMethodDecl MethodDef(JCModifiers mods,

   178                                Name name,

   179                                JCExpression restype,

   180                                List<JCTypeParameter> typarams,

   181                                List<JCVariableDecl> params,

   182                                List<JCTypeAnnotation> receiver,

   183                                List<JCExpression> thrown,

   184                                JCBlock body,

   185                                JCExpression defaultValue)

   186     {

   187         JCMethodDecl tree = new JCMethodDecl(mods,

   188                                        name,

   189                                        restype,

   190                                        typarams,

   191                                        params,

   192                                        receiver,

   193                                        thrown,

   194                                        body,

   195                                        defaultValue,

   196                                        null);

   197         tree.pos = pos;

   198         return tree;

   199     }

   201     public JCVariableDecl VarDef(JCModifiers mods, Name name, JCExpression vartype, JCExpression init) {

   202         JCVariableDecl tree = new JCVariableDecl(mods, name, vartype, init, null);

   203         tree.pos = pos;

   204         return tree;

   205     }

   207     public JCSkip Skip() {

   208         JCSkip tree = new JCSkip();

   209         tree.pos = pos;

   210         return tree;

   211     }

   213     public JCBlock Block(long flags, List<JCStatement> stats) {

   214         JCBlock tree = new JCBlock(flags, stats);

   215         tree.pos = pos;

   216         return tree;

   217     }

   219     public JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond) {

   220         JCDoWhileLoop tree = new JCDoWhileLoop(body, cond);

   221         tree.pos = pos;

   222         return tree;

   223     }

   225     public JCWhileLoop WhileLoop(JCExpression cond, JCStatement body) {

   226         JCWhileLoop tree = new JCWhileLoop(cond, body);

   227         tree.pos = pos;

   228         return tree;

   229     }

   231     public JCForLoop ForLoop(List<JCStatement> init,

   232                            JCExpression cond,

   233                            List<JCExpressionStatement> step,

   234                            JCStatement body)

   235     {

   236         JCForLoop tree = new JCForLoop(init, cond, step, body);

   237         tree.pos = pos;

   238         return tree;

   239     }

   241     public JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body) {

   242         JCEnhancedForLoop tree = new JCEnhancedForLoop(var, expr, body);

   243         tree.pos = pos;

   244         return tree;

   245     }

   247     public JCLabeledStatement Labelled(Name label, JCStatement body) {

   248         JCLabeledStatement tree = new JCLabeledStatement(label, body);

   249         tree.pos = pos;

   250         return tree;

   251     }

   253     public JCSwitch Switch(JCExpression selector, List<JCCase> cases) {

   254         JCSwitch tree = new JCSwitch(selector, cases);

   255         tree.pos = pos;

   256         return tree;

   257     }

   259     public JCCase Case(JCExpression pat, List<JCStatement> stats) {

   260         JCCase tree = new JCCase(pat, stats);

   261         tree.pos = pos;

   262         return tree;

   263     }

   265     public JCSynchronized Synchronized(JCExpression lock, JCBlock body) {

   266         JCSynchronized tree = new JCSynchronized(lock, body);

   267         tree.pos = pos;

   268         return tree;

   269     }

   271     public JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer) {

   272         return Try(List.<JCTree>nil(), body, catchers, finalizer);

   273     }

   275     public JCTry Try(List<JCTree> resources,

   276                      JCBlock body,

   277                      List<JCCatch> catchers,

   278                      JCBlock finalizer) {

   279         JCTry tree = new JCTry(resources, body, catchers, finalizer);

   280         tree.pos = pos;

   281         return tree;

   282     }

   284     public JCCatch Catch(JCVariableDecl param, JCBlock body) {

   285         JCCatch tree = new JCCatch(param, body);

   286         tree.pos = pos;

   287         return tree;

   288     }

   290     public JCConditional Conditional(JCExpression cond,

   291                                    JCExpression thenpart,

   292                                    JCExpression elsepart)

   293     {

   294         JCConditional tree = new JCConditional(cond, thenpart, elsepart);

   295         tree.pos = pos;

   296         return tree;

   297     }

   299     public JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart) {

   300         JCIf tree = new JCIf(cond, thenpart, elsepart);

   301         tree.pos = pos;

   302         return tree;

   303     }

   305     public JCExpressionStatement Exec(JCExpression expr) {

   306         JCExpressionStatement tree = new JCExpressionStatement(expr);

   307         tree.pos = pos;

   308         return tree;

   309     }

   311     public JCBreak Break(Name label) {

   312         JCBreak tree = new JCBreak(label, null);

   313         tree.pos = pos;

   314         return tree;

   315     }

   317     public JCContinue Continue(Name label) {

   318         JCContinue tree = new JCContinue(label, null);

   319         tree.pos = pos;

   320         return tree;

   321     }

   323     public JCReturn Return(JCExpression expr) {

   324         JCReturn tree = new JCReturn(expr);

   325         tree.pos = pos;

   326         return tree;

   327     }

   329     public JCThrow Throw(JCTree expr) {

   330         JCThrow tree = new JCThrow(expr);

   331         tree.pos = pos;

   332         return tree;

   333     }

   335     public JCAssert Assert(JCExpression cond, JCExpression detail) {

   336         JCAssert tree = new JCAssert(cond, detail);

   337         tree.pos = pos;

   338         return tree;

   339     }

   341     public JCMethodInvocation Apply(List<JCExpression> typeargs,

   342                        JCExpression fn,

   343                        List<JCExpression> args)

   344     {

   345         JCMethodInvocation tree = new JCMethodInvocation(typeargs, fn, args);

   346         tree.pos = pos;

   347         return tree;

   348     }

   350     public JCNewClass NewClass(JCExpression encl,

   351                              List<JCExpression> typeargs,

   352                              JCExpression clazz,

   353                              List<JCExpression> args,

   354                              JCClassDecl def)

   355     {

   356         JCNewClass tree = new JCNewClass(encl, typeargs, clazz, args, def);

   357         tree.pos = pos;

   358         return tree;

   359     }

   361     public JCNewArray NewArray(JCExpression elemtype,

   362                              List<JCExpression> dims,

   363                              List<JCExpression> elems)

   364     {

   365         JCNewArray tree = new JCNewArray(elemtype, dims, elems);

   366         tree.pos = pos;

   367         return tree;

   368     }

   370     public JCParens Parens(JCExpression expr) {

   371         JCParens tree = new JCParens(expr);

   372         tree.pos = pos;

   373         return tree;

   374     }

   376     public JCAssign Assign(JCExpression lhs, JCExpression rhs) {

   377         JCAssign tree = new JCAssign(lhs, rhs);

   378         tree.pos = pos;

   379         return tree;

   380     }

   382     public JCAssignOp Assignop(int opcode, JCTree lhs, JCTree rhs) {

   383         JCAssignOp tree = new JCAssignOp(opcode, lhs, rhs, null);

   384         tree.pos = pos;

   385         return tree;

   386     }

   388     public JCUnary Unary(int opcode, JCExpression arg) {

   389         JCUnary tree = new JCUnary(opcode, arg);

   390         tree.pos = pos;

   391         return tree;

   392     }

   394     public JCBinary Binary(int opcode, JCExpression lhs, JCExpression rhs) {

   395         JCBinary tree = new JCBinary(opcode, lhs, rhs, null);

   396         tree.pos = pos;

   397         return tree;

   398     }

   400     public JCTypeCast TypeCast(JCTree clazz, JCExpression expr) {

   401         JCTypeCast tree = new JCTypeCast(clazz, expr);

   402         tree.pos = pos;

   403         return tree;

   404     }

   406     public JCInstanceOf TypeTest(JCExpression expr, JCTree clazz) {

   407         JCInstanceOf tree = new JCInstanceOf(expr, clazz);

   408         tree.pos = pos;

   409         return tree;

   410     }

   412     public JCArrayAccess Indexed(JCExpression indexed, JCExpression index) {

   413         JCArrayAccess tree = new JCArrayAccess(indexed, index);

   414         tree.pos = pos;

   415         return tree;

   416     }

   418     public JCFieldAccess Select(JCExpression selected, Name selector) {

   419         JCFieldAccess tree = new JCFieldAccess(selected, selector, null);

   420         tree.pos = pos;

   421         return tree;

   422     }

   424     public JCIdent Ident(Name name) {

   425         JCIdent tree = new JCIdent(name, null);

   426         tree.pos = pos;

   427         return tree;

   428     }

   430     public JCLiteral Literal(int tag, Object value) {

   431         JCLiteral tree = new JCLiteral(tag, value);

   432         tree.pos = pos;

   433         return tree;

   434     }

   436     public JCPrimitiveTypeTree TypeIdent(int typetag) {

   437         JCPrimitiveTypeTree tree = new JCPrimitiveTypeTree(typetag);

   438         tree.pos = pos;

   439         return tree;

   440     }

   442     public JCArrayTypeTree TypeArray(JCExpression elemtype) {

   443         JCArrayTypeTree tree = new JCArrayTypeTree(elemtype);

   444         tree.pos = pos;

   445         return tree;

   446     }

   448     public JCTypeApply TypeApply(JCExpression clazz, List<JCExpression> arguments) {

   449         JCTypeApply tree = new JCTypeApply(clazz, arguments);

   450         tree.pos = pos;

   451         return tree;

   452     }

   454     public JCTypeDisjoint TypeDisjoint(List<JCExpression> components) {

   455         JCTypeDisjoint tree = new JCTypeDisjoint(components);

   456         tree.pos = pos;

   457         return tree;

   458     }

   460     public JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds) {

   461         return TypeParameter(name, bounds, List.<JCTypeAnnotation>nil());

   462     }

   464     public JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds, List<JCTypeAnnotation> annos) {

   465         JCTypeParameter tree = new JCTypeParameter(name, bounds, annos);

   466         tree.pos = pos;

   467         return tree;

   468     }

   470     public JCWildcard Wildcard(TypeBoundKind kind, JCTree type) {

   471         JCWildcard tree = new JCWildcard(kind, type);

   472         tree.pos = pos;

   473         return tree;

   474     }

   476     public TypeBoundKind TypeBoundKind(BoundKind kind) {

   477         TypeBoundKind tree = new TypeBoundKind(kind);

   478         tree.pos = pos;

   479         return tree;

   480     }

   482     public JCAnnotation Annotation(JCTree annotationType, List<JCExpression> args) {

   483         JCAnnotation tree = new JCAnnotation(annotationType, args);

   484         tree.pos = pos;

   485         return tree;

   486     }

   488     public JCTypeAnnotation TypeAnnotation(JCTree annotationType, List<JCExpression> args) {

   489         JCTypeAnnotation tree = new JCTypeAnnotation(annotationType, args);

   490         tree.pos = pos;

   491         return tree;

   492     }

   494     public JCModifiers Modifiers(long flags, List<JCAnnotation> annotations) {

   495         JCModifiers tree = new JCModifiers(flags, annotations);

   496         boolean noFlags = (flags & (Flags.ModifierFlags | Flags.ANNOTATION)) == 0;

   497         tree.pos = (noFlags && annotations.isEmpty()) ? Position.NOPOS : pos;

   498         return tree;

   499     }

   501     public JCModifiers Modifiers(long flags) {

   502         return Modifiers(flags, List.<JCAnnotation>nil());

   503     }

   505     public JCAnnotatedType AnnotatedType(List<JCTypeAnnotation> annotations, JCExpression underlyingType) {

   506         JCAnnotatedType tree = new JCAnnotatedType(annotations, underlyingType);

   507         tree.pos = pos;

   508         return tree;

   509     }

   511     public JCErroneous Erroneous() {

   512         return Erroneous(List.<JCTree>nil());

   513     }

   515     public JCErroneous Erroneous(List<? extends JCTree> errs) {

   516         JCErroneous tree = new JCErroneous(errs);

   517         tree.pos = pos;

   518         return tree;

   519     }

   521     public LetExpr LetExpr(List<JCVariableDecl> defs, JCTree expr) {

   522         LetExpr tree = new LetExpr(defs, expr);

   523         tree.pos = pos;

   524         return tree;

   525     }

   527 /* ***************************************************************************

   528  * Derived building blocks.

   529  ****************************************************************************/

   531     public JCClassDecl AnonymousClassDef(JCModifiers mods,

   532                                          List<JCTree> defs)

   533     {

   534         return ClassDef(mods,

   535                         names.empty,

   536                         List.<JCTypeParameter>nil(),

   537                         null,

   538                         List.<JCExpression>nil(),

   539                         defs);

   540     }

   542     public LetExpr LetExpr(JCVariableDecl def, JCTree expr) {

   543         LetExpr tree = new LetExpr(List.of(def), expr);

   544         tree.pos = pos;

   545         return tree;

   546     }

   548     /** Create an identifier from a symbol.

   549      */

   550     public JCIdent Ident(Symbol sym) {

   551         return (JCIdent)new JCIdent((sym.name != names.empty)

   552                                 ? sym.name

   553                                 : sym.flatName(), sym)

   554             .setPos(pos)

   555             .setType(sym.type);

   556     }

   558     /** Create a selection node from a qualifier tree and a symbol.

   559      *  @param base   The qualifier tree.

   560      */

   561     public JCExpression Select(JCExpression base, Symbol sym) {

   562         return new JCFieldAccess(base, sym.name, sym).setPos(pos).setType(sym.type);

   563     }

   565     /** Create a qualified identifier from a symbol, adding enough qualifications

   566      *  to make the reference unique.

   567      */

   568     public JCExpression QualIdent(Symbol sym) {

   569         return isUnqualifiable(sym)

   570             ? Ident(sym)

   571             : Select(QualIdent(sym.owner), sym);

   572     }

   574     /** Create an identifier that refers to the variable declared in given variable

   575      *  declaration.

   576      */

   577     public JCExpression Ident(JCVariableDecl param) {

   578         return Ident(param.sym);

   579     }

   581     /** Create a list of identifiers referring to the variables declared

   582      *  in given list of variable declarations.

   583      */

   584     public List<JCExpression> Idents(List<JCVariableDecl> params) {

   585         ListBuffer<JCExpression> ids = new ListBuffer<JCExpression>();

   586         for (List<JCVariableDecl> l = params; l.nonEmpty(); l = l.tail)

   587             ids.append(Ident(l.head));

   588         return ids.toList();

   589     }

   591     /** Create a tree representing `this', given its type.

   592      */

   593     public JCExpression This(Type t) {

   594         return Ident(new VarSymbol(FINAL, names._this, t, t.tsym));

   595     }

   597     /** Create a tree representing a class literal.

   598      */

   599     public JCExpression ClassLiteral(ClassSymbol clazz) {

   600         return ClassLiteral(clazz.type);

   601     }

   603     /** Create a tree representing a class literal.

   604      */

   605     public JCExpression ClassLiteral(Type t) {

   606         VarSymbol lit = new VarSymbol(STATIC | PUBLIC | FINAL,

   607                                       names._class,

   608                                       t,

   609                                       t.tsym);

   610         return Select(Type(t), lit);

   611     }

   613     /** Create a tree representing `super', given its type and owner.

   614      */

   615     public JCIdent Super(Type t, TypeSymbol owner) {

   616         return Ident(new VarSymbol(FINAL, names._super, t, owner));

   617     }

   619     /**

   620      * Create a method invocation from a method tree and a list of

   621      * argument trees.

   622      */

   623     public JCMethodInvocation App(JCExpression meth, List<JCExpression> args) {

   624         return Apply(null, meth, args).setType(meth.type.getReturnType());

   625     }

   627     /**

   628      * Create a no-arg method invocation from a method tree

   629      */

   630     public JCMethodInvocation App(JCExpression meth) {

   631         return Apply(null, meth, List.<JCExpression>nil()).setType(meth.type.getReturnType());

   632     }

   634     /** Create a method invocation from a method tree and a list of argument trees.

   635      */

   636     public JCExpression Create(Symbol ctor, List<JCExpression> args) {

   637         Type t = ctor.owner.erasure(types);

   638         JCNewClass newclass = NewClass(null, null, Type(t), args, null);

   639         newclass.constructor = ctor;

   640         newclass.setType(t);

   641         return newclass;

   642     }

   644     /** Create a tree representing given type.

   645      */

   646     public JCExpression Type(Type t) {

   647         if (t == null) return null;

   648         JCExpression tp;

   649         switch (t.tag) {

   650         case BYTE: case CHAR: case SHORT: case INT: case LONG: case FLOAT:

   651         case DOUBLE: case BOOLEAN: case VOID:

   652             tp = TypeIdent(t.tag);

   653             break;

   654         case TYPEVAR:

   655             tp = Ident(t.tsym);

   656             break;

   657         case WILDCARD: {

   658             WildcardType a = ((WildcardType) t);

   659             tp = Wildcard(TypeBoundKind(a.kind), Type(a.type));

   660             break;

   661         }

   662         case CLASS:

   663             Type outer = t.getEnclosingType();

   664             JCExpression clazz = outer.tag == CLASS && t.tsym.owner.kind == TYP

   665                 ? Select(Type(outer), t.tsym)

   666                 : QualIdent(t.tsym);

   667             tp = t.getTypeArguments().isEmpty()

   668                 ? clazz

   669                 : TypeApply(clazz, Types(t.getTypeArguments()));

   670             break;

   671         case ARRAY:

   672             tp = TypeArray(Type(types.elemtype(t)));

   673             break;

   674         case ERROR:

   675             tp = TypeIdent(ERROR);

   676             break;

   677         default:

   678             throw new AssertionError("unexpected type: " + t);

   679         }

   680         return tp.setType(t);

   681     }

   682 //where

   683         private JCExpression Selectors(JCExpression base, Symbol sym, Symbol limit) {

   684             if (sym == limit) return base;

   685             else return Select(Selectors(base, sym.owner, limit), sym);

   686         }

   688     /** Create a list of trees representing given list of types.

   689      */

   690     public List<JCExpression> Types(List<Type> ts) {

   691         ListBuffer<JCExpression> types = new ListBuffer<JCExpression>();

   692         for (List<Type> l = ts; l.nonEmpty(); l = l.tail)

   693             types.append(Type(l.head));

   694         return types.toList();

   695     }

   697     /** Create a variable definition from a variable symbol and an initializer

   698      *  expression.

   699      */

   700     public JCVariableDecl VarDef(VarSymbol v, JCExpression init) {

   701         return (JCVariableDecl)

   702             new JCVariableDecl(

   703                 Modifiers(v.flags(), Annotations(v.getAnnotationMirrors())),

   704                 v.name,

   705                 Type(v.type),

   706                 init,

   707                 v).setPos(pos).setType(v.type);

   708     }

   710     /** Create annotation trees from annotations.

   711      */

   712     public List<JCAnnotation> Annotations(List<Attribute.Compound> attributes) {

   713         if (attributes == null) return List.nil();

   714         ListBuffer<JCAnnotation> result = new ListBuffer<JCAnnotation>();

   715         for (List<Attribute.Compound> i = attributes; i.nonEmpty(); i=i.tail) {

   716             Attribute a = i.head;

   717             result.append(Annotation(a));

   718         }

   719         return result.toList();

   720     }

   722     public JCLiteral Literal(Object value) {

   723         JCLiteral result = null;

   724         if (value instanceof String) {

   725             result = Literal(CLASS, value).

   726                 setType(syms.stringType.constType(value));

   727         } else if (value instanceof Integer) {

   728             result = Literal(INT, value).

   729                 setType(syms.intType.constType(value));

   730         } else if (value instanceof Long) {

   731             result = Literal(LONG, value).

   732                 setType(syms.longType.constType(value));

   733         } else if (value instanceof Byte) {

   734             result = Literal(BYTE, value).

   735                 setType(syms.byteType.constType(value));

   736         } else if (value instanceof Character) {

   737             result = Literal(CHAR, value).

   738                 setType(syms.charType.constType(value));

   739         } else if (value instanceof Double) {

   740             result = Literal(DOUBLE, value).

   741                 setType(syms.doubleType.constType(value));

   742         } else if (value instanceof Float) {

   743             result = Literal(FLOAT, value).

   744                 setType(syms.floatType.constType(value));

   745         } else if (value instanceof Short) {

   746             result = Literal(SHORT, value).

   747                 setType(syms.shortType.constType(value));

   748         } else {

   749             throw new AssertionError(value);

   750         }

   751         return result;

   752     }

   754     class AnnotationBuilder implements Attribute.Visitor {

   755         JCExpression result = null;

   756         public void visitConstant(Attribute.Constant v) {

   757             result = Literal(v.value);

   758         }

   759         public void visitClass(Attribute.Class clazz) {

   760             result = ClassLiteral(clazz.type).setType(syms.classType);

   761         }

   762         public void visitEnum(Attribute.Enum e) {

   763             result = QualIdent(e.value);

   764         }

   765         public void visitError(Attribute.Error e) {

   766             result = Erroneous();

   767         }

   768         public void visitCompound(Attribute.Compound compound) {

   769             result = visitCompoundInternal(compound);

   770         }

   771         public JCAnnotation visitCompoundInternal(Attribute.Compound compound) {

   772             ListBuffer<JCExpression> args = new ListBuffer<JCExpression>();

   773             for (List<Pair<Symbol.MethodSymbol,Attribute>> values = compound.values; values.nonEmpty(); values=values.tail) {

   774                 Pair<MethodSymbol,Attribute> pair = values.head;

   775                 JCExpression valueTree = translate(pair.snd);

   776                 args.append(Assign(Ident(pair.fst), valueTree).setType(valueTree.type));

   777             }

   778             return Annotation(Type(compound.type), args.toList());

   779         }

   780         public void visitArray(Attribute.Array array) {

   781             ListBuffer<JCExpression> elems = new ListBuffer<JCExpression>();

   782             for (int i = 0; i < array.values.length; i++)

   783                 elems.append(translate(array.values[i]));

   784             result = NewArray(null, List.<JCExpression>nil(), elems.toList()).setType(array.type);

   785         }

   786         JCExpression translate(Attribute a) {

   787             a.accept(this);

   788             return result;

   789         }

   790         JCAnnotation translate(Attribute.Compound a) {

   791             return visitCompoundInternal(a);

   792         }

   793     }

   794     AnnotationBuilder annotationBuilder = new AnnotationBuilder();

   796     /** Create an annotation tree from an attribute.

   797      */

   798     public JCAnnotation Annotation(Attribute a) {

   799         return annotationBuilder.translate((Attribute.Compound)a);

   800     }

   802     /** Create a method definition from a method symbol and a method body.

   803      */

   804     public JCMethodDecl MethodDef(MethodSymbol m, JCBlock body) {

   805         return MethodDef(m, m.type, body);

   806     }

   808     /** Create a method definition from a method symbol, method type

   809      *  and a method body.

   810      */

   811     public JCMethodDecl MethodDef(MethodSymbol m, Type mtype, JCBlock body) {

   812         return (JCMethodDecl)

   813             new JCMethodDecl(

   814                 Modifiers(m.flags(), Annotations(m.getAnnotationMirrors())),

   815                 m.name,

   816                 Type(mtype.getReturnType()),

   817                 TypeParams(mtype.getTypeArguments()),

   818                 Params(mtype.getParameterTypes(), m),

   819                 null,

   820                 Types(mtype.getThrownTypes()),

   821                 body,

   822                 null,

   823                 m).setPos(pos).setType(mtype);

   824     }

   826     /** Create a type parameter tree from its name and type.

   827      */

   828     public JCTypeParameter TypeParam(Name name, TypeVar tvar) {

   829         return (JCTypeParameter)

   830             TypeParameter(name, Types(types.getBounds(tvar))).setPos(pos).setType(tvar);

   831     }

   833     /** Create a list of type parameter trees from a list of type variables.

   834      */

   835     public List<JCTypeParameter> TypeParams(List<Type> typarams) {

   836         ListBuffer<JCTypeParameter> tparams = new ListBuffer<JCTypeParameter>();

   837         int i = 0;

   838         for (List<Type> l = typarams; l.nonEmpty(); l = l.tail)

   839             tparams.append(TypeParam(l.head.tsym.name, (TypeVar)l.head));

   840         return tparams.toList();

   841     }

   843     /** Create a value parameter tree from its name, type, and owner.

   844      */

   845     public JCVariableDecl Param(Name name, Type argtype, Symbol owner) {

   846         return VarDef(new VarSymbol(0, name, argtype, owner), null);

   847     }

   849     /** Create a a list of value parameter trees x0, ..., xn from a list of

   850      *  their types and an their owner.

   851      */

   852     public List<JCVariableDecl> Params(List<Type> argtypes, Symbol owner) {

   853         ListBuffer<JCVariableDecl> params = new ListBuffer<JCVariableDecl>();

   854         MethodSymbol mth = (owner.kind == MTH) ? ((MethodSymbol)owner) : null;

   855         if (mth != null && mth.params != null && argtypes.length() == mth.params.length()) {

   856             for (VarSymbol param : ((MethodSymbol)owner).params)

   857                 params.append(VarDef(param, null));

   858         } else {

   859             int i = 0;

   860             for (List<Type> l = argtypes; l.nonEmpty(); l = l.tail)

   861                 params.append(Param(paramName(i++), l.head, owner));

   862         }

   863         return params.toList();

   864     }

   866     /** Wrap a method invocation in an expression statement or return statement,

   867      *  depending on whether the method invocation expression's type is void.

   868      */

   869     public JCStatement Call(JCExpression apply) {

   870         return apply.type.tag == VOID ? Exec(apply) : Return(apply);

   871     }

   873     /** Construct an assignment from a variable symbol and a right hand side.

   874      */

   875     public JCStatement Assignment(Symbol v, JCExpression rhs) {

   876         return Exec(Assign(Ident(v), rhs).setType(v.type));

   877     }

   879     /** Construct an index expression from a variable and an expression.

   880      */

   881     public JCArrayAccess Indexed(Symbol v, JCExpression index) {

   882         JCArrayAccess tree = new JCArrayAccess(QualIdent(v), index);

   883         tree.type = ((ArrayType)v.type).elemtype;

   884         return tree;

   885     }

   887     /** Make an attributed type cast expression.

   888      */

   889     public JCTypeCast TypeCast(Type type, JCExpression expr) {

   890         return (JCTypeCast)TypeCast(Type(type), expr).setType(type);

   891     }

   893 /* ***************************************************************************

   894  * Helper methods.

   895  ****************************************************************************/

   897     /** Can given symbol be referred to in unqualified form?

   898      */

   899     boolean isUnqualifiable(Symbol sym) {

   900         if (sym.name == names.empty ||

   901             sym.owner == null ||

   902             sym.owner.kind == MTH || sym.owner.kind == VAR) {

   903             return true;

   904         } else if (sym.kind == TYP && toplevel != null) {

   905             Scope.Entry e;

   906             e = toplevel.namedImportScope.lookup(sym.name);

   907             if (e.scope != null) {

   908                 return

   909                   e.sym == sym &&

   910                   e.next().scope == null;

   911             }

   912             e = toplevel.packge.members().lookup(sym.name);

   913             if (e.scope != null) {

   914                 return

   915                   e.sym == sym &&

   916                   e.next().scope == null;

   917             }

   918             e = toplevel.starImportScope.lookup(sym.name);

   919             if (e.scope != null) {

   920                 return

   921                   e.sym == sym &&

   922                   e.next().scope == null;

   923             }

   924         }

   925         return false;

   926     }

   928     /** The name of synthetic parameter number `i'.

   929      */

   930     public Name paramName(int i)   { return names.fromString("x" + i); }

   932     /** The name of synthetic type parameter number `i'.

   933      */

   934     public Name typaramName(int i) { return names.fromString("A" + i); }

   935 }

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

src/share/classes/com/sun/tools/javac/tree/TreeMaker.java@4851ff2ffc10

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