jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Check.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
 */
 package com.sun.tools.javac.comp;
 import java.util.*;
-import java.util.Set;
 import javax.tools.JavaFileManager;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.util.List;
-import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.code.Lint;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.comp.DeferredAttr.DeferredAttrContext;
 import com.sun.tools.javac.comp.Infer.InferenceContext;
 import com.sun.tools.javac.comp.Infer.InferenceContext.FreeTypeListener;
+import com.sun.tools.javac.tree.JCTree.*;
+import com.sun.tools.javac.tree.JCTree.JCPolyExpression.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Flags.ANNOTATION;
 import static com.sun.tools.javac.code.Flags.SYNCHRONIZED;
 import static com.sun.tools.javac.code.Kinds.*;
 protected Check(Context context) {
 context.put(checkKey, this);
 names = Names.instance(context);
+dfltTargetMeta = new Name[] { names.PACKAGE, names.TYPE,
+names.FIELD, names.METHOD, names.CONSTRUCTOR,
+names.ANNOTATION_TYPE, names.LOCAL_VARIABLE, names.PARAMETER};
 log = Log.instance(context);
 rs = Resolve.instance(context);
 syms = Symtab.instance(context);
 enter = Enter.instance(context);
 deferredAttr = DeferredAttr.instance(context);
 */
 public void checkRedundantCast(Env<AttrContext> env, JCTypeCast tree) {
 if (!tree.type.isErroneous() &&
 (env.info.lint == null || env.info.lint.isEnabled(Lint.LintCategory.CAST))
 && types.isSameType(tree.expr.type, tree.clazz.type)
+&& !(ignoreAnnotatedCasts && TreeInfo.containsTypeAnnotation(tree.clazz))
 && !is292targetTypeCast(tree)) {
 log.warning(Lint.LintCategory.CAST,
 tree.pos(), "redundant.cast", tree.expr.type);
 }
 }
 //where
 private boolean is292targetTypeCast(JCTypeCast tree) {
 boolean is292targetTypeCast = false;
 JCExpression expr = TreeInfo.skipParens(tree.expr);
 if (expr.hasTag(APPLY)) {
 JCMethodInvocation apply = (JCMethodInvocation)expr;
 Symbol sym = TreeInfo.symbol(apply.meth);
 is292targetTypeCast = sym != null &&
 sym.kind == MTH &&
 (sym.flags() & HYPOTHETICAL) != 0;
 }
 return is292targetTypeCast;
 }
+private static final boolean ignoreAnnotatedCasts = true;
-//where
-/** Is type a type variable, or a (possibly multi-dimensional) array of
-*  type variables?
-*/
-boolean isTypeVar(Type t) {
-return t.hasTag(TYPEVAR) || t.hasTag(ARRAY) && isTypeVar(types.elemtype(t));
-}
 /** Check that a type is within some bounds.
 *
 *  Used in TypeApply to verify that, e.g., X in {@code V<X>} is a valid
 *  type argument.
 } else {
 return t;
 }
 }
+Type checkClassOrArrayType(DiagnosticPosition pos, Type t) {
+if (!t.hasTag(CLASS) && !t.hasTag(ARRAY) && !t.hasTag(ERROR)) {
+return typeTagError(pos,
+diags.fragment("type.req.class.array"),
+asTypeParam(t));
+} else {
+return t;
+}
+}
 /** Check that type is a class or interface type.
 *  @param pos           Position to be used for error reporting.
 *  @param t             The type to be checked.
 */
 Type checkClassType(DiagnosticPosition pos, Type t) {
-if (!t.hasTag(CLASS) && !t.hasTag(ERROR))
+if (!t.hasTag(CLASS) && !t.hasTag(ERROR)) {
 return typeTagError(pos,
 diags.fragment("type.req.class"),
-(t.hasTag(TYPEVAR))
+asTypeParam(t));
-? diags.fragment("type.parameter", t)
+} else {
-: t);
-else
 return t;
 }
+}
+//where
+private Object asTypeParam(Type t) {
+return (t.hasTag(TYPEVAR))
+? diags.fragment("type.parameter", t)
+: t;
+}
 /** Check that type is a valid qualifier for a constructor reference expression
 */
 Type checkConstructorRefType(DiagnosticPosition pos, Type t) {
-t = checkClassType(pos, t);
+t = checkClassOrArrayType(pos, t);
 if (t.hasTag(CLASS)) {
 if ((t.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {
 log.error(pos, "abstract.cant.be.instantiated");
 t = types.createErrorType(t);
 } else if ((t.tsym.flags() & ENUM) != 0) {
 /** Check that type is a reifiable class, interface or array type.
 *  @param pos           Position to be used for error reporting.
 *  @param t             The type to be checked.
 */
 Type checkReifiableReferenceType(DiagnosticPosition pos, Type t) {
-if (!t.hasTag(CLASS) && !t.hasTag(ARRAY) && !t.hasTag(ERROR)) {
+t = checkClassOrArrayType(pos, t);
-return typeTagError(pos,
+if (!t.isErroneous() && !types.isReifiable(t)) {
-diags.fragment("type.req.class.array"),
-t);
-} else if (!types.isReifiable(t)) {
 log.error(pos, "illegal.generic.type.for.instof");
 return types.createErrorType(t);
 } else {
 return t;
 }
 // System.out.println("call   : " + env.tree);
 // System.out.println("method : " + owntype);
 // System.out.println("actuals: " + argtypes);
 List<Type> formals = owntype.getParameterTypes();
 Type last = useVarargs ? formals.last() : null;
-if (sym.name==names.init &&
+if (sym.name == names.init &&
 sym.owner == syms.enumSym)
 formals = formals.tail.tail;
 List<JCExpression> args = argtrees;
 DeferredAttr.DeferredTypeMap checkDeferredMap =
 deferredAttr.new DeferredTypeMap(DeferredAttr.AttrMode.CHECK, sym, env.info.pendingResolutionPhase);
 types.erasure(owntype.getReturnType()),
 types.erasure(owntype.getThrownTypes()),
 syms.methodClass);
 }
 if (useVarargs) {
-JCTree tree = env.tree;
 Type argtype = owntype.getParameterTypes().last();
 if (!types.isReifiable(argtype) &&
 (!allowSimplifiedVarargs ||
 sym.attribute(syms.trustMeType.tsym) == null ||
 !isTrustMeAllowedOnMethod(sym))) {
 warnUnchecked(env.tree.pos(),
 "unchecked.generic.array.creation",
 argtype);
 }
 if (!((MethodSymbol)sym.baseSymbol()).isSignaturePolymorphic(types)) {
-Type elemtype = types.elemtype(argtype);
+TreeInfo.setVarargsElement(env.tree, types.elemtype(argtype));
-switch (tree.getTag()) {
-case APPLY:
-((JCMethodInvocation) tree).varargsElement = elemtype;
-break;
-case NEWCLASS:
-((JCNewClass) tree).varargsElement = elemtype;
-break;
-case REFERENCE:
-((JCMemberReference) tree).varargsElement = elemtype;
-break;
-default:
-throw new AssertionError(""+tree);
-}
 }
 }
+PolyKind pkind = (sym.type.hasTag(FORALL) &&
+sym.type.getReturnType().containsAny(((ForAll)sym.type).tvars)) ?
+PolyKind.POLY : PolyKind.STANDALONE;
+TreeInfo.setPolyKind(env.tree, pkind);
 return owntype;
 }
 //where
 private void assertConvertible(JCTree tree, Type actual, Type formal, Warner warn) {
 if (types.isConvertible(actual, formal, warn))
 implicit = PRIVATE;
 mask = PRIVATE;
 } else
 mask = ConstructorFlags;
 }  else if ((sym.owner.flags_field & INTERFACE) != 0) {
-if ((flags & DEFAULT) != 0) {
+if ((flags & (DEFAULT | STATIC)) != 0) {
-mask = InterfaceDefaultMethodMask;
+mask = InterfaceMethodMask;
-implicit = PUBLIC | ABSTRACT;
+implicit = PUBLIC;
+if ((flags & DEFAULT) != 0) {
+implicit |= ABSTRACT;
+}
 } else {
 mask = implicit = InterfaceMethodFlags;
 }
 }
 else {
 // ISSUE: Disallowing abstract&private is no longer appropriate
 // in the presence of inner classes. Should it be deleted here?
 checkDisjoint(pos, flags,
 ABSTRACT,
 PRIVATE | STATIC | DEFAULT))
+&&
+checkDisjoint(pos, flags,
+STATIC,
+DEFAULT)
 &&
 checkDisjoint(pos, flags,
 ABSTRACT | INTERFACE,
 FINAL | NATIVE | SYNCHRONIZED)
 &&
 log.error(tree.pos(), "cant.select.static.class.from.param.type");
 } else {
 // otherwise validate the rest of the expression
 tree.selected.accept(this);
 }
+}
+@Override
+public void visitAnnotatedType(JCAnnotatedType tree) {
+tree.underlyingType.accept(this);
 }
 /** Default visitor method: do nothing.
 */
 @Override
 *  @param tree         The class definition whose members are checked.
 */
 void checkImplementations(JCClassDecl tree) {
 checkImplementations(tree, tree.sym, tree.sym);
 }
 //where
 /** Check that all methods which implement some
 *  method in `ic' conform to the method they implement.
 */
 void checkImplementations(JCTree tree, ClassSymbol origin, ClassSymbol ic) {
 for (List<Type> l = types.closure(ic.type); l.nonEmpty(); l = l.tail) {
 public void validateAnnotations(List<JCAnnotation> annotations, Symbol s) {
 for (JCAnnotation a : annotations)
 validateAnnotation(a, s);
 }
+/** Check the type annotations.
+*/
+public void validateTypeAnnotations(List<JCAnnotation> annotations, boolean isTypeParameter) {
+for (JCAnnotation a : annotations)
+validateTypeAnnotation(a, isTypeParameter);
+}
 /** Check an annotation of a symbol.
 */
 private void validateAnnotation(JCAnnotation a, Symbol s) {
 validateAnnotationTree(a);
 if (a.annotationType.type.tsym == syms.overrideType.tsym) {
 if (!isOverrider(s))
 log.error(a.pos(), "method.does.not.override.superclass");
 }
+if (a.annotationType.type.tsym == syms.functionalInterfaceType.tsym) {
+if (s.kind != TYP) {
+log.error(a.pos(), "bad.functional.intf.anno");
+} else {
+try {
+types.findDescriptorSymbol((TypeSymbol)s);
+} catch (Types.FunctionDescriptorLookupError ex) {
+log.error(a.pos(), "bad.functional.intf.anno.1", ex.getDiagnostic());
+}
+}
+}
+}
+public void validateTypeAnnotation(JCAnnotation a, boolean isTypeParameter) {
+Assert.checkNonNull(a.type, "annotation tree hasn't been attributed yet: " + a);
+validateAnnotationTree(a);
+if (!isTypeAnnotation(a, isTypeParameter))
+log.error(a.pos(), "annotation.type.not.applicable");
 }
 /**
-* Validate the proposed container 'containedBy' on the
+* Validate the proposed container 'repeatable' on the
 * annotation type symbol 's'. Report errors at position
 * 'pos'.
 *
-* @param s The (annotation)type declaration annotated with a @ContainedBy
+* @param s The (annotation)type declaration annotated with a @Repeatable
-* @param containedBy the @ContainedBy on 's'
+* @param repeatable the @Repeatable on 's'
 * @param pos where to report errors
 */
-public void validateContainedBy(TypeSymbol s, Attribute.Compound containedBy, DiagnosticPosition pos) {
+public void validateRepeatable(TypeSymbol s, Attribute.Compound repeatable, DiagnosticPosition pos) {
-Assert.check(types.isSameType(containedBy.type, syms.containedByType));
+Assert.check(types.isSameType(repeatable.type, syms.repeatableType));
 Type t = null;
-List<Pair<MethodSymbol,Attribute>> l = containedBy.values;
+List<Pair<MethodSymbol,Attribute>> l = repeatable.values;
 if (!l.isEmpty()) {
 Assert.check(l.head.fst.name == names.value);
 t = ((Attribute.Class)l.head.snd).getValue();
 }
 if (t == null) {
-log.error(pos, "invalid.container.wrong.containedby", s, containedBy);
+// errors should already have been reported during Annotate
 return;
 }
-validateHasContainerFor(t.tsym, s, pos);
+validateValue(t.tsym, s, pos);
 validateRetention(t.tsym, s, pos);
 validateDocumented(t.tsym, s, pos);
 validateInherited(t.tsym, s, pos);
 validateTarget(t.tsym, s, pos);
 validateDefault(t.tsym, s, pos);
 }
-/**
+private void validateValue(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
-* Validate the proposed container 'containerFor' on the
+Scope.Entry e = container.members().lookup(names.value);
-* annotation type symbol 's'. Report errors at position
+if (e.scope != null && e.sym.kind == MTH) {
-* 'pos'.
+MethodSymbol m = (MethodSymbol) e.sym;
-*
+Type ret = m.getReturnType();
-* @param s The (annotation)type declaration annotated with a @ContainerFor
+if (!(ret.hasTag(ARRAY) && types.isSameType(((ArrayType)ret).elemtype, contained.type))) {
-* @param containerFor the @ContainedFor on 's'
+log.error(pos, "invalid.repeatable.annotation.value.return",
-* @param pos where to report errors
+container, ret, types.makeArrayType(contained.type));
-*/
+}
-public void validateContainerFor(TypeSymbol s, Attribute.Compound containerFor, DiagnosticPosition pos) {
+} else {
-Assert.check(types.isSameType(containerFor.type, syms.containerForType));
+log.error(pos, "invalid.repeatable.annotation.no.value", container);
+}
-Type t = null;
-List<Pair<MethodSymbol,Attribute>> l = containerFor.values;
-if (!l.isEmpty()) {
-Assert.check(l.head.fst.name == names.value);
-t = ((Attribute.Class)l.head.snd).getValue();
-}
-if (t == null) {
-log.error(pos, "invalid.container.wrong.containerfor", s, containerFor);
-return;
-}
-validateHasContainedBy(t.tsym, s, pos);
-}
-private void validateHasContainedBy(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
-Attribute.Compound containedBy = container.attribute(syms.containedByType.tsym);
-if (containedBy == null) {
-log.error(pos, "invalid.container.no.containedby", container, syms.containedByType.tsym);
-return;
-}
-Type t = null;
-List<Pair<MethodSymbol,Attribute>> l = containedBy.values;
-if (!l.isEmpty()) {
-Assert.check(l.head.fst.name == names.value);
-t = ((Attribute.Class)l.head.snd).getValue();
-}
-if (t == null) {
-log.error(pos, "invalid.container.wrong.containedby", container, contained);
-return;
-}
-if (!types.isSameType(t, contained.type))
-log.error(pos, "invalid.container.wrong.containedby", t.tsym, contained);
-}
-private void validateHasContainerFor(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
-Attribute.Compound containerFor = container.attribute(syms.containerForType.tsym);
-if (containerFor == null) {
-log.error(pos, "invalid.container.no.containerfor", container, syms.containerForType.tsym);
-return;
-}
-Type t = null;
-List<Pair<MethodSymbol,Attribute>> l = containerFor.values;
-if (!l.isEmpty()) {
-Assert.check(l.head.fst.name == names.value);
-t = ((Attribute.Class)l.head.snd).getValue();
-}
-if (t == null) {
-log.error(pos, "invalid.container.wrong.containerfor", container, contained);
-return;
-}
-if (!types.isSameType(t, contained.type))
-log.error(pos, "invalid.container.wrong.containerfor", t.tsym, contained);
 }
 private void validateRetention(Symbol container, Symbol contained, DiagnosticPosition pos) {
 Attribute.RetentionPolicy containerRetention = types.getRetention(container);
 Attribute.RetentionPolicy containedRetention = types.getRetention(contained);
 if (containerRetention == Attribute.RetentionPolicy.SOURCE)  {
 error = true;
 }
 }
 if (error ) {
-log.error(pos, "invalid.containedby.annotation.retention",
+log.error(pos, "invalid.repeatable.annotation.retention",
 container, containerRetention,
 contained, containedRetention);
 }
 }
 private void validateDocumented(Symbol container, Symbol contained, DiagnosticPosition pos) {
 if (contained.attribute(syms.documentedType.tsym) != null) {
 if (container.attribute(syms.documentedType.tsym) == null) {
-log.error(pos, "invalid.containedby.annotation.not.documented", container, contained);
+log.error(pos, "invalid.repeatable.annotation.not.documented", container, contained);
 }
 }
 }
 private void validateInherited(Symbol container, Symbol contained, DiagnosticPosition pos) {
 if (contained.attribute(syms.inheritedType.tsym) != null) {
 if (container.attribute(syms.inheritedType.tsym) == null) {
-log.error(pos, "invalid.containedby.annotation.not.inherited", container, contained);
+log.error(pos, "invalid.repeatable.annotation.not.inherited", container, contained);
 }
 }
 }
 private void validateTarget(Symbol container, Symbol contained, DiagnosticPosition pos) {
 // trivially true if contained has no target as per above).
 // contained has target, but container has not, error
 Attribute.Array containerTarget = getAttributeTargetAttribute(container);
 if (containerTarget == null) {
-log.error(pos, "invalid.containedby.annotation.incompatible.target", container, contained);
+log.error(pos, "invalid.repeatable.annotation.incompatible.target", container, contained);
 return;
 }
 Set<Name> containerTargets = new HashSet<Name>();
 for (Attribute app : containerTarget.values) {
 Attribute.Enum e = (Attribute.Enum)app;
 containedTargets.add(e.value.name);
 }
 if (!isTargetSubset(containedTargets, containerTargets)) {
-log.error(pos, "invalid.containedby.annotation.incompatible.target", container, contained);
+log.error(pos, "invalid.repeatable.annotation.incompatible.target", container, contained);
 }
 }
 /** Checks that t is a subset of s, with respect to ElementType
 * semantics, specifically {ANNOTATION_TYPE} is a subset of {TYPE}
 for(Symbol elm : scope.getElements()) {
 if (elm.name != names.value &&
 elm.kind == Kinds.MTH &&
 ((MethodSymbol)elm).defaultValue == null) {
 log.error(pos,
-"invalid.containedby.annotation.elem.nondefault",
+"invalid.repeatable.annotation.elem.nondefault",
 container,
 elm);
 }
 }
 }
 }
 }
 return false;
 }
+/** Is the annotation applicable to type annotations? */
+protected boolean isTypeAnnotation(JCAnnotation a, boolean isTypeParameter) {
+Attribute.Compound atTarget =
+a.annotationType.type.tsym.attribute(syms.annotationTargetType.tsym);
+if (atTarget == null) {
+// An annotation without @Target is not a type annotation.
+return false;
+}
+Attribute atValue = atTarget.member(names.value);
+if (!(atValue instanceof Attribute.Array)) {
+return false; // error recovery
+}
+Attribute.Array arr = (Attribute.Array) atValue;
+for (Attribute app : arr.values) {
+if (!(app instanceof Attribute.Enum)) {
+return false; // recovery
+}
+Attribute.Enum e = (Attribute.Enum) app;
+if (e.value.name == names.TYPE_USE)
+return true;
+else if (isTypeParameter && e.value.name == names.TYPE_PARAMETER)
+return true;
+}
+return false;
+}
 /** Is the annotation applicable to the symbol? */
 boolean annotationApplicable(JCAnnotation a, Symbol s) {
 Attribute.Array arr = getAttributeTargetAttribute(a.annotationType.type.tsym);
+Name[] targets;
 if (arr == null) {
-return true;
+targets = defaultTargetMetaInfo(a, s);
-}
+} else {
-for (Attribute app : arr.values) {
+// TODO: can we optimize this?
-if (!(app instanceof Attribute.Enum)) return true; // recovery
+targets = new Name[arr.values.length];
-Attribute.Enum e = (Attribute.Enum) app;
+for (int i=0; i<arr.values.length; ++i) {
-if (e.value.name == names.TYPE)
+Attribute app = arr.values[i];
+if (!(app instanceof Attribute.Enum)) {
+return true; // recovery
+}
+Attribute.Enum e = (Attribute.Enum) app;
+targets[i] = e.value.name;
+}
+}
+for (Name target : targets) {
+if (target == names.TYPE)
 { if (s.kind == TYP) return true; }
-else if (e.value.name == names.FIELD)
+else if (target == names.FIELD)
 { if (s.kind == VAR && s.owner.kind != MTH) return true; }
-else if (e.value.name == names.METHOD)
+else if (target == names.METHOD)
 { if (s.kind == MTH && !s.isConstructor()) return true; }
-else if (e.value.name == names.PARAMETER)
+else if (target == names.PARAMETER)
 { if (s.kind == VAR &&
 s.owner.kind == MTH &&
 (s.flags() & PARAMETER) != 0)
 return true;
 }
-else if (e.value.name == names.CONSTRUCTOR)
+else if (target == names.CONSTRUCTOR)
 { if (s.kind == MTH && s.isConstructor()) return true; }
-else if (e.value.name == names.LOCAL_VARIABLE)
+else if (target == names.LOCAL_VARIABLE)
 { if (s.kind == VAR && s.owner.kind == MTH &&
 (s.flags() & PARAMETER) == 0)
 return true;
 }
-else if (e.value.name == names.ANNOTATION_TYPE)
+else if (target == names.ANNOTATION_TYPE)
 { if (s.kind == TYP && (s.flags() & ANNOTATION) != 0)
 return true;
 }
-else if (e.value.name == names.PACKAGE)
+else if (target == names.PACKAGE)
 { if (s.kind == PCK) return true; }
-else if (e.value.name == names.TYPE_USE)
+else if (target == names.TYPE_USE)
 { if (s.kind == TYP ||
 s.kind == VAR ||
 (s.kind == MTH && !s.isConstructor() &&
-!s.type.getReturnType().hasTag(VOID)))
+!s.type.getReturnType().hasTag(VOID)) ||
+(s.kind == MTH && s.isConstructor()))
+return true;
+}
+else if (target == names.TYPE_PARAMETER)
+{ if (s.kind == TYP && s.type.hasTag(TYPEVAR))
 return true;
 }
 else
 return true; // recovery
 }
 s.attribute(syms.annotationTargetType.tsym);
 if (atTarget == null) return null; // ok, is applicable
 Attribute atValue = atTarget.member(names.value);
 if (!(atValue instanceof Attribute.Array)) return null; // error recovery
 return (Attribute.Array) atValue;
+}
+private final Name[] dfltTargetMeta;
+private Name[] defaultTargetMetaInfo(JCAnnotation a, Symbol s) {
+return dfltTargetMeta;
 }
 /** Check an annotation value.
 *
 * @param a The annotation tree to check

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

comparison: src/share/classes/com/sun/tools/javac/comp/Check.java

src/share/classes/com/sun/tools/javac/comp/Check.java