Java TypeKind Example

说明

java typekind示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Java

类/类型: TypeKind

示例#1
文件: Types.java项目: jingweno/com.google.dart.compiler

  private boolean isSubtypeOfInterface(Type t, InterfaceType s) {
    // Special handling for union.
    if (t instanceof InterfaceTypeUnion) {
      InterfaceTypeUnion tUnion = (InterfaceTypeUnion) t;
      for (InterfaceType unionPart : tUnion.getTypes()) {
        if (isSubtype(unionPart, s)) {
          return true;
        }
      }
      return false;
    }

    // class "t" implements call() and "s" is Function
    if (TypeKind.of(t) == TypeKind.INTERFACE
        && typeProvider != null
        && s == typeProvider.getFunctionType()) {
      InterfaceType ti = (InterfaceType) t;
      if (ti.lookupMember("call") != null) {
        return true;
      }
    }

    // Try to cast "t" to "s".
    final Type sup = asInstanceOf(t, s.getElement());
    if (TypeKind.of(sup) == TypeKind.INTERFACE) {
      InterfaceType ti = (InterfaceType) sup;
      assert ti.getElement().equals(s.getElement());
      if (ti.isRaw() || s.isRaw()) {
        return true;
      }
      // Type arguments are covariant.
      return areSubtypes(ti.getArguments().iterator(), s.getArguments().iterator());
    }
    return false;
  }

示例#2
文件: T7042566.java项目: krichter722/jdk9-jdk9-langtools

 boolean isApplicable(TypeConfiguration that) {
   List<TypeKind> actuals = that.typeKindList;
   List<TypeKind> formals = parameterTypes.typeKindList;
   if ((actuals.size() - formals.size()) < -1) return false; // not enough args
   for (TypeKind actual : actuals) {
     if (!actual.isSubtypeOf(formals.head)) return false; // type mismatch
     formals = formals.tail.isEmpty() ? formals : formals.tail;
   }
   return true;
 }

示例#3
文件: T6199075.java项目: som-snytt/ceylon-compiler

  void test() throws Exception {
    for (TypeKind formal1 : TypeKind.values()) {
      VarargsMethod m1 = new VarargsMethod(formal1);
      for (TypeKind formal2 : TypeKind.values()) {
        VarargsMethod m2 = new VarargsMethod(formal2);
        for (TypeKind actual : TypeKind.values()) {
          for (ArgumentsArity argsArity : ArgumentsArity.values()) {
            compileAndCheck(m1, m2, actual, argsArity);
          }
        }
      }
    }

    System.out.println("Total checks made: " + checkCount);
    System.out.println("Bytecode checks made: " + bytecodeCheckCount);
  }

示例#4
文件: JavacTypes.java项目: w7cook/batch-javac

 public NoType getNoType(TypeKind kind) {
   switch (kind) {
     case VOID:
       return syms.voidType;
     case NONE:
       return Type.noType;
     default:
       throw new IllegalArgumentException(kind.toString());
   }
 }

示例#5
文件: Types.java项目: jingweno/com.google.dart.compiler

 public static InterfaceType ensureInterface(Type type) {
   TypeKind kind = TypeKind.of(type);
   switch (kind) {
     case INTERFACE:
       return (InterfaceType) type;
     case NONE:
     case DYNAMIC:
       return null;
     default:
       throw new AssertionError("unexpected kind " + kind);
   }
 }

示例#6
文件: Types.java项目: jingweno/com.google.dart.compiler

 /**
  * Return an interface type representing the given interface, function or variable type.
  *
  * @return An interface type or null if the argument is neither an interface function or variable
  *     type.
  */
 public InterfaceType getInterfaceType(Type type) {
   switch (TypeKind.of(type)) {
     case VARIABLE:
       {
         TypeVariableElement element = ((TypeVariable) type).getTypeVariableElement();
         if (element.getBound() == null) {
           return typeProvider.getObjectType();
         } else {
           return getInterfaceType(element.getBound());
         }
       }
     case FUNCTION:
     case FUNCTION_ALIAS:
       return typeProvider.getFunctionType();
     case INTERFACE:
       return (InterfaceType) type;
     case DYNAMIC:
     case NONE:
     case VOID:
     default:
       return null;
   }
 }

示例#7
文件: Types.java项目: jingweno/com.google.dart.compiler

 public Type intersection(List<Type> types) {
   // exclude 'dynamic' type
   {
     List<Type> newTypes = Lists.newArrayList();
     for (Type type : types) {
       if (TypeKind.of(type) != TypeKind.DYNAMIC) {
         newTypes.add(type);
       }
     }
     types = newTypes;
   }
   // no types, so Dynamic
   if (types.isEmpty()) {
     return typeProvider.getDynamicType();
   }
   // prepare all super types
   List<List<InterfaceType>> superTypesLists = Lists.newArrayList();
   List<Map<InterfaceType, InterfaceType>> superTypesMaps = Lists.newArrayList();
   for (Type type : types) {
     List<InterfaceType> superTypes = getSuperTypes(type);
     superTypesLists.add(superTypes);
     Map<InterfaceType, InterfaceType> superTypesMap = Maps.newHashMap();
     for (InterfaceType superType : superTypes) {
       superTypesMap.put(superType.asRawType(), superType);
     }
     superTypesMaps.add(superTypesMap);
   }
   // find intersection of super types
   LinkedList<InterfaceType> interTypes = Lists.newLinkedList();
   if (superTypesLists.size() > 0) {
     for (InterfaceType superType : superTypesLists.get(0)) {
       boolean inAll = true;
       for (Map<InterfaceType, InterfaceType> otherTypesMap : superTypesMaps) {
         InterfaceType superTypeRaw = superType.asRawType();
         InterfaceType otherType = otherTypesMap.get(superTypeRaw);
         // no such raw type, exclude from intersection
         if (otherType == null) {
           inAll = false;
           break;
         }
         // if not raw, choose type arguments
         if (!superType.getArguments().isEmpty()) {
           InterfaceType t0 = superType;
           InterfaceType t1 = otherType;
           // if two-way sub-type, then has Dynamic(s), choose with least number
           if (isSubtype(t0, t1) && isSubtype(t1, t0)) {
             int dynamics0 = getDynamicArgumentsCount(t0);
             int dynamics1 = getDynamicArgumentsCount(t1);
             if (dynamics0 < dynamics1) {
               superType = t0;
             } else {
               superType = t1;
             }
             continue;
           }
           // use super-type of t0 and t1
           if (isSubtype(t0, t1)) {
             superType = t1;
           }
           if (isSubtype(t1, t0)) {
             superType = t0;
           }
         }
       }
       if (inAll && !interTypes.contains(superType)) {
         interTypes.add(superType);
       }
     }
   }
   // try to remove sub-types already covered by existing types
   for (Iterator<InterfaceType> i = interTypes.descendingIterator(); i.hasNext(); ) {
     InterfaceType subType = i.next();
     boolean hasSuperType = false;
     for (InterfaceType superType : interTypes) {
       if (superType != subType && isSubtype(superType, subType)) {
         hasSuperType = true;
         break;
       }
     }
     if (hasSuperType) {
       i.remove();
     }
   }
   // use single type
   if (interTypes.size() == 0) {
     return typeProvider.getObjectType();
   }
   if (interTypes.size() == 1) {
     return interTypes.get(0);
   }
   // create union
   return unionTypes(interTypes);
 }

示例#8
文件: Types.java项目: jingweno/com.google.dart.compiler

 private InterfaceType checkedAsInstanceOf(
     Type t, ClassElement element, Set<TypeVariable> variablesReferenced, Set<Type> checkedTypes) {
   // check for recursion
   if (checkedTypes.contains(t)) {
     return null;
   }
   checkedTypes.add(t);
   // check current Type
   switch (TypeKind.of(t)) {
     case FUNCTION_ALIAS:
     case INTERFACE:
       {
         if (t.getElement().equals(element)) {
           return (InterfaceType) t;
         }
         InterfaceType ti = (InterfaceType) t;
         ClassElement tElement = ti.getElement();
         InterfaceType supertype = tElement.getSupertype();
         // super type
         if (supertype != null) {
           InterfaceType result =
               checkedAsInstanceOf(
                   asSupertype(ti, supertype), element, variablesReferenced, checkedTypes);
           if (result != null) {
             return result;
           }
         }
         // interfaces
         for (InterfaceType intf : tElement.getInterfaces()) {
           InterfaceType result =
               checkedAsInstanceOf(
                   asSupertype(ti, intf), element, variablesReferenced, checkedTypes);
           if (result != null) {
             return result;
           }
         }
         // mixins
         for (InterfaceType mixin : tElement.getMixins()) {
           if (mixin.getElement().equals(element)) {
             return asSupertype(ti, mixin);
           }
         }
         // no
         return null;
       }
     case FUNCTION:
       {
         Element e = t.getElement();
         switch (e.getKind()) {
           case CLASS:
             // e should be the interface Function in the core library. See the
             // documentation comment on FunctionType.
             InterfaceType ti = (InterfaceType) e.getType();
             return checkedAsInstanceOf(ti, element, variablesReferenced, checkedTypes);
           default:
             return null;
         }
       }
     case VARIABLE:
       {
         TypeVariable v = (TypeVariable) t;
         Type bound = v.getTypeVariableElement().getBound();
         // Check for previously encountered variables to avoid getting stuck in an infinite loop.
         if (variablesReferenced.contains(v)) {
           if (bound instanceof InterfaceType) {
             return (InterfaceType) bound;
           }
           return typeProvider.getObjectType();
         }
         variablesReferenced.add(v);
         return checkedAsInstanceOf(bound, element, variablesReferenced, checkedTypes);
       }
     default:
       return null;
   }
 }

示例#9
文件: T6199075.java项目: som-snytt/ceylon-compiler

 boolean isMoreSpecificThan(VarargsMethod that) {
   return varargsElement.isSubtypeOf(that.varargsElement);
 }

示例#10
文件: T6199075.java项目: som-snytt/ceylon-compiler

 boolean isApplicable(TypeKind actual, ArgumentsArity argsArity) {
   return argsArity == ArgumentsArity.ZERO || actual.isSubtypeOf(varargsElement);
 }

展开阅读全文