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

-:475eb15dfdad
+:f91144b7da75
 /*
-* Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 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
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.WeakHashMap;
+import javax.lang.model.type.TypeKind;
 import com.sun.tools.javac.code.Attribute.RetentionPolicy;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
 import com.sun.tools.javac.comp.Check;
 import com.sun.tools.javac.jvm.ClassReader;
 import com.sun.tools.javac.util.*;
-import com.sun.tools.javac.util.List;
 import static com.sun.tools.javac.code.BoundKind.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Scope.*;
 import static com.sun.tools.javac.code.Symbol.*;
 import static com.sun.tools.javac.code.Type.*;
 public Symbol getSymbol() {
 return descSym;
 }
-public Type getType(Type origin) {
+public Type getType(Type site) {
-return memberType(origin, descSym);
+if (capture(site) != site) {
+Type formalInterface = site.tsym.type;
+ListBuffer<Type> typeargs = ListBuffer.lb();
+List<Type> actualTypeargs = site.getTypeArguments();
+//simply replace the wildcards with its bound
+for (Type t : formalInterface.getTypeArguments()) {
+if (actualTypeargs.head.hasTag(WILDCARD)) {
+WildcardType wt = (WildcardType)actualTypeargs.head;
+typeargs.append(wt.type);
+} else {
+typeargs.append(actualTypeargs.head);
+}
+actualTypeargs = actualTypeargs.tail;
+}
+site = subst(formalInterface, formalInterface.getTypeArguments(), typeargs.toList());
+if (!chk.checkValidGenericType(site)) {
+//if the inferred functional interface type is not well-formed,
+//or if it's not a subtype of the original target, issue an error
+throw failure(diags.fragment("no.suitable.functional.intf.inst", site));
+}
+}
+return memberType(site, descSym);
 }
 }
 class Entry {
 final FunctionDescriptor cachedDescRes;
 /**
 * Compute the function descriptor associated with a given functional interface
 */
 public FunctionDescriptor findDescriptorInternal(TypeSymbol origin, CompoundScope membersCache) throws FunctionDescriptorLookupError {
-if (!origin.isInterface()) {
+if (!origin.isInterface() || (origin.flags() & ANNOTATION) != 0) {
 //t must be an interface
-throw failure("not.a.functional.intf");
+throw failure("not.a.functional.intf", origin);
 }
 final ListBuffer<Symbol> abstracts = ListBuffer.lb();
 for (Symbol sym : membersCache.getElements(new DescriptorFilter(origin))) {
 Type mtype = memberType(origin.type, sym);
 (sym.name == abstracts.first().name &&
 overrideEquivalent(mtype, memberType(origin.type, abstracts.first())))) {
 abstracts.append(sym);
 } else {
 //the target method(s) should be the only abstract members of t
-throw failure("not.a.functional.intf.1",
+throw failure("not.a.functional.intf.1",  origin,
 diags.fragment("incompatible.abstracts", Kinds.kindName(origin), origin));
 }
 }
 if (abstracts.isEmpty()) {
 //t must define a suitable non-generic method
-throw failure("not.a.functional.intf.1",
+throw failure("not.a.functional.intf.1", origin,
 diags.fragment("no.abstracts", Kinds.kindName(origin), origin));
 } else if (abstracts.size() == 1) {
 return new FunctionDescriptor(abstracts.first());
 } else { // size > 1
 FunctionDescriptor descRes = mergeDescriptors(origin, abstracts.toList());
 return true;
 } catch (FunctionDescriptorLookupError ex) {
 return false;
 }
 }
+public boolean isFunctionalInterface(Type site) {
+try {
+findDescriptorType(site);
+return true;
+} catch (FunctionDescriptorLookupError ex) {
+return false;
+}
+}
 // </editor-fold>
 /**
 * Scope filter used to skip methods that should be ignored (such as methods
 * overridden by j.l.Object) during function interface conversion/marker interface checks
 return result;
 }
 //where
 private boolean isSubtypeUncheckedInternal(Type t, Type s, Warner warn) {
 if (t.hasTag(ARRAY) && s.hasTag(ARRAY)) {
+t = t.unannotatedType();
+s = s.unannotatedType();
 if (((ArrayType)t).elemtype.isPrimitive()) {
 return isSameType(elemtype(t), elemtype(s));
 } else {
 return isSubtypeUnchecked(elemtype(t), elemtype(s), warn);
 }
 }
 return false;
 }
 private void checkUnsafeVarargsConversion(Type t, Type s, Warner warn) {
-if (t.tag != ARRAY || isReifiable(t)) return;
+if (t.tag != ARRAY || isReifiable(t))
+return;
+t = t.unannotatedType();
+s = s.unannotatedType();
 ArrayType from = (ArrayType)t;
 boolean shouldWarn = false;
 switch (s.tag) {
 case ARRAY:
 ArrayType to = (ArrayType)s;
 }
 final public boolean isSubtypeNoCapture(Type t, Type s) {
 return isSubtype(t, s, false);
 }
 public boolean isSubtype(Type t, Type s, boolean capture) {
+if (t == s)
+return true;
+t = t.unannotatedType();
+s = s.unannotatedType();
 if (t == s)
 return true;
 if (s.isPartial())
 return isSuperType(s, t);
 public Type elemtype(Type t) {
 switch (t.tag) {
 case WILDCARD:
 return elemtype(upperBound(t));
 case ARRAY:
+t = t.unannotatedType();
 return ((ArrayType)t).elemtype;
 case FORALL:
 return elemtype(((ForAll)t).qtype);
 case ERROR:
 return t;
 }
 @Override
 public Type visitErrorType(ErrorType t, Boolean recurse) {
 return t;
+}
+@Override
+public Type visitAnnotatedType(AnnotatedType t, Boolean recurse) {
+return new AnnotatedType(t.typeAnnotations, erasure(t.underlyingType, recurse));
 }
 };
 private Mapping erasureFun = new Mapping ("erasure") {
 public Type apply(Type t) { return erasure(t); }
 * The rank of a class is the length of the longest path between
 * the class and java.lang.Object in the class inheritance
 * graph. Undefined for all but reference types.
 */
 public int rank(Type t) {
+t = t.unannotatedType();
 switch(t.tag) {
 case CLASS: {
 ClassType cls = (ClassType)t;
 if (cls.rank_field < 0) {
 Name fullname = cls.tsym.getQualifiedName();
 if (capturedEncl != t.getEnclosingType()) {
 Type type1 = memberType(capturedEncl, t.tsym);
 t = subst(type1, t.tsym.type.getTypeArguments(), t.getTypeArguments());
 }
 }
+t = t.unannotatedType();
 ClassType cls = (ClassType)t;
 if (cls.isRaw() || !cls.isParameterized())
 return cls;
 ClassType G = (ClassType)cls.asElement().asType();
 public R visitTypeVar(TypeVar t, S s)           { return visitType(t, s); }
 public R visitCapturedType(CapturedType t, S s) { return visitType(t, s); }
 public R visitForAll(ForAll t, S s)             { return visitType(t, s); }
 public R visitUndetVar(UndetVar t, S s)         { return visitType(t, s); }
 public R visitErrorType(ErrorType t, S s)       { return visitType(t, s); }
+// Pretend annotations don't exist
+public R visitAnnotatedType(AnnotatedType t, S s) { return visit(t.underlyingType, s); }
 }
 /**
 * A default visitor for symbols.  All visitor methods except
 * visitSymbol are implemented by delegating to visitSymbol.  Concrete

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

comparison: src/share/classes/com/sun/tools/javac/code/Types.java

src/share/classes/com/sun/tools/javac/code/Types.java