Save This Page
Home » openjdk-7 » com.sun.tools » apt » mirror » util » [javadoc | source]
    1   /*
    2    * Copyright (c) 2004, 2005, 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    */
   25   
   26   package com.sun.tools.apt.mirror.util;
   27   
   28   
   29   import java.util.Collection;
   30   
   31   import com.sun.mirror.declaration;
   32   import com.sun.mirror.type;
   33   import com.sun.mirror.util.Types;
   34   import com.sun.tools.apt.mirror.AptEnv;
   35   import com.sun.tools.apt.mirror.declaration;
   36   import com.sun.tools.apt.mirror.type.TypeMirrorImpl;
   37   import com.sun.tools.javac.code.BoundKind;
   38   import com.sun.tools.javac.code.Type;
   39   import com.sun.tools.javac.code.Symbol.ClassSymbol;
   40   import com.sun.tools.javac.util.Context;
   41   import com.sun.tools.javac.util.ListBuffer;
   42   
   43   
   44   /**
   45    * Implementation of Types utility methods for annotation processors
   46    */
   47   @SuppressWarnings("deprecation")
   48   public class TypesImpl implements Types {
   49   
   50       private final AptEnv env;
   51   
   52   
   53       private static final Context.Key<Types> typesKey =
   54               new Context.Key<Types>();
   55   
   56       public static Types instance(Context context) {
   57           Types instance = context.get(typesKey);
   58           if (instance == null) {
   59               instance = new TypesImpl(context);
   60           }
   61           return instance;
   62       }
   63   
   64       private TypesImpl(Context context) {
   65           context.put(typesKey, this);
   66           env = AptEnv.instance(context);
   67       }
   68   
   69   
   70       /**
   71        * {@inheritDoc}
   72        */
   73       public boolean isSubtype(TypeMirror t1, TypeMirror t2) {
   74           return env.jctypes.isSubtype(((TypeMirrorImpl) t1).type,
   75                                        ((TypeMirrorImpl) t2).type);
   76       }
   77   
   78       /**
   79        * {@inheritDoc}
   80        */
   81       public boolean isAssignable(TypeMirror t1, TypeMirror t2) {
   82           return env.jctypes.isAssignable(((TypeMirrorImpl) t1).type,
   83                                           ((TypeMirrorImpl) t2).type);
   84       }
   85   
   86       /**
   87        * {@inheritDoc}
   88        */
   89       public TypeMirror getErasure(TypeMirror t) {
   90           return env.typeMaker.getType(
   91                   env.jctypes.erasure(((TypeMirrorImpl) t).type));
   92       }
   93   
   94       /**
   95        * {@inheritDoc}
   96        */
   97       public PrimitiveType getPrimitiveType(PrimitiveType.Kind kind) {
   98           Type prim = null;
   99           switch (kind) {
  100           case BOOLEAN:   prim = env.symtab.booleanType;  break;
  101           case BYTE:      prim = env.symtab.byteType;     break;
  102           case SHORT:     prim = env.symtab.shortType;    break;
  103           case INT:       prim = env.symtab.intType;      break;
  104           case LONG:      prim = env.symtab.longType;     break;
  105           case CHAR:      prim = env.symtab.charType;     break;
  106           case FLOAT:     prim = env.symtab.floatType;    break;
  107           case DOUBLE:    prim = env.symtab.doubleType;   break;
  108           default:        assert false;
  109           }
  110           return (PrimitiveType) env.typeMaker.getType(prim);
  111       }
  112   
  113       /**
  114        * {@inheritDoc}
  115        */
  116       public VoidType getVoidType() {
  117           return (VoidType) env.typeMaker.getType(env.symtab.voidType);
  118       }
  119   
  120       /**
  121        * {@inheritDoc}
  122        */
  123       public ArrayType getArrayType(TypeMirror componentType) {
  124           if (componentType instanceof VoidType) {
  125               throw new IllegalArgumentException("void");
  126           }
  127           return (ArrayType) env.typeMaker.getType(
  128                   new Type.ArrayType(((TypeMirrorImpl) componentType).type,
  129                                      env.symtab.arrayClass));
  130       }
  131   
  132       /**
  133        * {@inheritDoc}
  134        */
  135       public TypeVariable getTypeVariable(TypeParameterDeclaration tparam) {
  136           return (TypeVariable) env.typeMaker.getType(
  137                                   ((DeclarationImpl) tparam).sym.type);
  138       }
  139   
  140       /**
  141        * {@inheritDoc}
  142        */
  143       public WildcardType getWildcardType(Collection<ReferenceType> upperBounds,
  144                                           Collection<ReferenceType> lowerBounds) {
  145           BoundKind kind;
  146           Type bound;
  147           int uppers  = upperBounds.size();
  148           int downers = lowerBounds.size();
  149   
  150           if (uppers + downers > 1) {
  151               throw new IllegalArgumentException("Multiple bounds not allowed");
  152   
  153           } else if (uppers + downers == 0) {
  154               kind = BoundKind.UNBOUND;
  155               bound = env.symtab.objectType;
  156   
  157           } else if (uppers == 1) {
  158               assert downers == 0;
  159               kind = BoundKind.EXTENDS;
  160               bound = ((TypeMirrorImpl) upperBounds.iterator().next()).type;
  161   
  162           } else {
  163               assert uppers == 0 && downers == 1;
  164               kind = BoundKind.SUPER;
  165               bound = ((TypeMirrorImpl) lowerBounds.iterator().next()).type;
  166           }
  167   
  168           if (bound instanceof Type.WildcardType)
  169               throw new IllegalArgumentException(bound.toString());
  170   
  171           return (WildcardType) env.typeMaker.getType(
  172                   new Type.WildcardType(bound, kind, env.symtab.boundClass));
  173       }
  174   
  175       /**
  176        * {@inheritDoc}
  177        */
  178       public DeclaredType getDeclaredType(TypeDeclaration decl,
  179                                           TypeMirror... typeArgs) {
  180           ClassSymbol sym = ((TypeDeclarationImpl) decl).sym;
  181   
  182           if (typeArgs.length == 0)
  183               return (DeclaredType) env.typeMaker.getType(
  184                                           env.jctypes.erasure(sym.type));
  185           if (sym.type.getEnclosingType().isParameterized())
  186               throw new IllegalArgumentException(decl.toString());
  187   
  188           return getDeclaredType(sym.type.getEnclosingType(), sym, typeArgs);
  189       }
  190   
  191       /**
  192        * {@inheritDoc}
  193        */
  194       public DeclaredType getDeclaredType(DeclaredType containing,
  195                                           TypeDeclaration decl,
  196                                           TypeMirror... typeArgs) {
  197           if (containing == null)
  198               return getDeclaredType(decl, typeArgs);
  199   
  200           ClassSymbol sym = ((TypeDeclarationImpl) decl).sym;
  201           Type outer = ((TypeMirrorImpl) containing).type;
  202   
  203           if (outer.tsym != sym.owner.enclClass())
  204               throw new IllegalArgumentException(containing.toString());
  205           if (!outer.isParameterized())
  206               return getDeclaredType(decl, typeArgs);
  207   
  208           return getDeclaredType(outer, sym, typeArgs);
  209       }
  210   
  211       private DeclaredType getDeclaredType(Type outer,
  212                                            ClassSymbol sym,
  213                                            TypeMirror... typeArgs) {
  214           if (typeArgs.length != sym.type.getTypeArguments().length())
  215               throw new IllegalArgumentException(
  216                                   "Incorrect number of type arguments");
  217   
  218           ListBuffer<Type> targs = new ListBuffer<Type>();
  219           for (TypeMirror t : typeArgs) {
  220               if (!(t instanceof ReferenceType || t instanceof WildcardType))
  221                   throw new IllegalArgumentException(t.toString());
  222               targs.append(((TypeMirrorImpl) t).type);
  223           }
  224           //### Need a way to check that type args match formals.
  225   
  226           return (DeclaredType) env.typeMaker.getType(
  227                   new Type.ClassType(outer, targs.toList(), sym));
  228       }
  229   }

Save This Page
Home » openjdk-7 » com.sun.tools » apt » mirror » util » [javadoc | source]