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

-:be10ac0081b2
+:6debfa63a4a1
 allowBoxing = source.allowBoxing();
 allowCovariantReturns = source.allowCovariantReturns();
 allowAnonOuterThis = source.allowAnonOuterThis();
 allowStringsInSwitch = source.allowStringsInSwitch();
 allowPoly = source.allowPoly();
+allowTypeAnnos = source.allowTypeAnnotations();
 allowLambda = source.allowLambda();
 allowDefaultMethods = source.allowDefaultMethods();
 sourceName = source.name;
 relax = (options.isSet("-retrofit") ||
 options.isSet("-relax"));
 identifyLambdaCandidate = options.getBoolean("identifyLambdaCandidate", false);
 statInfo = new ResultInfo(NIL, Type.noType);
 varInfo = new ResultInfo(VAR, Type.noType);
 unknownExprInfo = new ResultInfo(VAL, Type.noType);
+unknownAnyPolyInfo = new ResultInfo(VAL, Infer.anyPoly);
 unknownTypeInfo = new ResultInfo(TYP, Type.noType);
 unknownTypeExprInfo = new ResultInfo(Kinds.TYP | Kinds.VAL, Type.noType);
 recoveryInfo = new RecoveryInfo(deferredAttr.emptyDeferredAttrContext);
 }
 boolean relax;
 /** Switch: support target-typing inference
 */
 boolean allowPoly;
+/** Switch: support type annotations.
+*/
+boolean allowTypeAnnos;
 /** Switch: support generics?
 */
 boolean allowGenerics;
 */
 Type check(final JCTree tree, final Type found, final int ownkind, final ResultInfo resultInfo) {
 InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();
 Type owntype = found;
 if (!owntype.hasTag(ERROR) && !resultInfo.pt.hasTag(METHOD) && !resultInfo.pt.hasTag(FORALL)) {
-if (inferenceContext.free(found)) {
+if (allowPoly && inferenceContext.free(found)) {
 inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt), new FreeTypeListener() {
 @Override
 public void typesInferred(InferenceContext inferenceContext) {
 ResultInfo pendingResult =
 resultInfo.dup(inferenceContext.asInstType(resultInfo.pt));
 }
 }
 final ResultInfo statInfo;
 final ResultInfo varInfo;
+final ResultInfo unknownAnyPolyInfo;
 final ResultInfo unknownExprInfo;
 final ResultInfo unknownTypeInfo;
 final ResultInfo unknownTypeExprInfo;
 final ResultInfo recoveryInfo;
 <T extends JCTree> void attribStats(List<T> trees, Env<AttrContext> env) {
 for (List<T> l = trees; l.nonEmpty(); l = l.tail)
 attribStat(l.head, env);
 }
-/** Attribute the arguments in a method call, returning a list of types.
+/** Attribute the arguments in a method call, returning the method kind.
 */
-List<Type> attribArgs(List<JCExpression> trees, Env<AttrContext> env) {
+int attribArgs(List<JCExpression> trees, Env<AttrContext> env, ListBuffer<Type> argtypes) {
-ListBuffer<Type> argtypes = new ListBuffer<Type>();
+int kind = VAL;
 for (JCExpression arg : trees) {
-Type argtype = allowPoly && deferredAttr.isDeferred(env, arg) ?
+Type argtype;
-deferredAttr.new DeferredType(arg, env) :
+if (allowPoly && deferredAttr.isDeferred(env, arg)) {
-chk.checkNonVoid(arg, attribExpr(arg, env, Infer.anyPoly));
+argtype = deferredAttr.new DeferredType(arg, env);
+kind |= POLY;
+} else {
+argtype = chk.checkNonVoid(arg, attribTree(arg, env, unknownAnyPolyInfo));
+}
 argtypes.append(argtype);
 }
-return argtypes.toList();
+return kind;
 }
 /** Attribute a type argument list, returning a list of types.
 *  Caller is responsible for calling checkRefTypes.
 */
 Name methName = TreeInfo.name(tree.meth);
 boolean isConstructorCall =
 methName == names._this || methName == names._super;
+ListBuffer<Type> argtypesBuf = ListBuffer.lb();
 if (isConstructorCall) {
 // We are seeing a ...this(...) or ...super(...) call.
 // Check that this is the first statement in a constructor.
 if (checkFirstConstructorStat(tree, env)) {
 // Record the fact
 // that this is a constructor call (using isSelfCall).
 localEnv.info.isSelfCall = true;
 // Attribute arguments, yielding list of argument types.
-argtypes = attribArgs(tree.args, localEnv);
+attribArgs(tree.args, localEnv, argtypesBuf);
+argtypes = argtypesBuf.toList();
 typeargtypes = attribTypes(tree.typeargs, localEnv);
 // Variable `site' points to the class in which the called
 // constructor is defined.
 Type site = env.enclClass.sym.type;
 }
 result = tree.type = syms.voidType;
 } else {
 // Otherwise, we are seeing a regular method call.
 // Attribute the arguments, yielding list of argument types, ...
-argtypes = attribArgs(tree.args, localEnv);
+int kind = attribArgs(tree.args, localEnv, argtypesBuf);
+argtypes = argtypesBuf.toList();
 typeargtypes = attribAnyTypes(tree.typeargs, localEnv);
 // ... and attribute the method using as a prototype a methodtype
 // whose formal argument types is exactly the list of actual
 // arguments (this will also set the method symbol).
 Type mpt = newMethodTemplate(resultInfo.pt, argtypes, typeargtypes);
 localEnv.info.pendingResolutionPhase = null;
-Type mtype = attribTree(tree.meth, localEnv, new ResultInfo(VAL, mpt, resultInfo.checkContext));
+Type mtype = attribTree(tree.meth, localEnv, new ResultInfo(kind, mpt, resultInfo.checkContext));
 // Compute the result type.
 Type restype = mtype.getReturnType();
 if (restype.hasTag(WILDCARD))
 throw new AssertionError(mtype);
 // Check for the existence of an apropos outer instance
 rs.resolveImplicitThis(tree.pos(), env, clazztype);
 }
 // Attribute constructor arguments.
-List<Type> argtypes = attribArgs(tree.args, localEnv);
+ListBuffer<Type> argtypesBuf = ListBuffer.lb();
+int pkind = attribArgs(tree.args, localEnv, argtypesBuf);
+List<Type> argtypes = argtypesBuf.toList();
 List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv);
 // If we have made no mistakes in the class type...
 if (clazztype.hasTag(CLASS)) {
 // Enums may not be instantiated except implicitly
 if (cdef == null) { //do not check twice!
 tree.constructorType = checkId(tree,
 clazztype,
 tree.constructor,
 rsEnv,
-new ResultInfo(MTH, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
+new ResultInfo(pkind, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
 if (rsEnv.info.lastResolveVarargs())
 Assert.check(tree.constructorType.isErroneous() || tree.varargsElement != null);
 }
-findDiamondIfNeeded(localEnv, tree, clazztype);
+if (cdef == null &&
+!clazztype.isErroneous() &&
+clazztype.getTypeArguments().nonEmpty() &&
+findDiamonds) {
+findDiamond(localEnv, tree, clazztype);
+}
 }
 if (cdef != null) {
 // We are seeing an anonymous class instance creation.
 // In this case, the class instance creation
 tree.constructor = sym;
 tree.constructorType = checkId(tree,
 clazztype,
 tree.constructor,
 localEnv,
-new ResultInfo(VAL, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
+new ResultInfo(pkind, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
 } else {
 if (tree.clazz.hasTag(ANNOTATED_TYPE)) {
 checkForDeclarationAnnotations(((JCAnnotatedType) tree.clazz).annotations,
 tree.clazz.type.tsym);
 }
 }
 result = check(tree, owntype, VAL, resultInfo);
 chk.validate(tree.typeargs, localEnv);
 }
 //where
-void findDiamondIfNeeded(Env<AttrContext> env, JCNewClass tree, Type clazztype) {
+void findDiamond(Env<AttrContext> env, JCNewClass tree, Type clazztype) {
-if (tree.def == null &&
+JCTypeApply ta = (JCTypeApply)tree.clazz;
-!clazztype.isErroneous() &&
+List<JCExpression> prevTypeargs = ta.arguments;
-clazztype.getTypeArguments().nonEmpty() &&
+try {
-findDiamonds) {
+//create a 'fake' diamond AST node by removing type-argument trees
-JCTypeApply ta = (JCTypeApply)tree.clazz;
+ta.arguments = List.nil();
-List<JCExpression> prevTypeargs = ta.arguments;
+ResultInfo findDiamondResult = new ResultInfo(VAL,
-try {
+resultInfo.checkContext.inferenceContext().free(resultInfo.pt) ? Type.noType : pt());
-//create a 'fake' diamond AST node by removing type-argument trees
+Type inferred = deferredAttr.attribSpeculative(tree, env, findDiamondResult).type;
-ta.arguments = List.nil();
+Type polyPt = allowPoly ?
-ResultInfo findDiamondResult = new ResultInfo(VAL,
+syms.objectType :
-resultInfo.checkContext.inferenceContext().free(resultInfo.pt) ? Type.noType : pt());
+clazztype;
-Type inferred = deferredAttr.attribSpeculative(tree, env, findDiamondResult).type;
+if (!inferred.isErroneous() &&
-Type polyPt = allowPoly ?
+types.isAssignable(inferred, pt().hasTag(NONE) ? polyPt : pt(), types.noWarnings)) {
-syms.objectType :
+String key = types.isSameType(clazztype, inferred) ?
-clazztype;
+"diamond.redundant.args" :
-if (!inferred.isErroneous() &&
+"diamond.redundant.args.1";
-types.isAssignable(inferred, pt().hasTag(NONE) ? polyPt : pt(), types.noWarnings)) {
+log.warning(tree.clazz.pos(), key, clazztype, inferred);
-String key = types.isSameType(clazztype, inferred) ?
+}
-"diamond.redundant.args" :
+} finally {
-"diamond.redundant.args.1";
+ta.arguments = prevTypeargs;
-log.warning(tree.clazz.pos(), key, clazztype, inferred);
-}
-} finally {
-ta.arguments = prevTypeargs;
-}
 }
 }
 private void checkLambdaCandidate(JCNewClass tree, ClassSymbol csym, Type clazztype) {
 if (allowLambda &&
 //see Infer.instantiatePolymorphicSignatureInstance()
 Env<AttrContext> localEnv = env.dup(tree);
 //should we propagate the target type?
 final ResultInfo castInfo;
 JCExpression expr = TreeInfo.skipParens(tree.expr);
-boolean isPoly = expr.hasTag(LAMBDA) || expr.hasTag(REFERENCE);
+boolean isPoly = allowPoly && (expr.hasTag(LAMBDA) || expr.hasTag(REFERENCE));
 if (isPoly) {
 //expression is a poly - we need to propagate target type info
 castInfo = new ResultInfo(VAL, clazztype, new Check.NestedCheckContext(resultInfo.checkContext) {
 @Override
 public boolean compatible(Type found, Type req, Warner warn) {
 Type checkMethodIdInternal(JCTree tree,
 Type site,
 Symbol sym,
 Env<AttrContext> env,
 ResultInfo resultInfo) {
-Type pt = resultInfo.pt.map(deferredAttr.new RecoveryDeferredTypeMap(AttrMode.SPECULATIVE, sym, env.info.pendingResolutionPhase));
+if ((resultInfo.pkind & POLY) != 0) {
-Type owntype = checkIdInternal(tree, site, sym, pt, env, resultInfo);
+Type pt = resultInfo.pt.map(deferredAttr.new RecoveryDeferredTypeMap(AttrMode.SPECULATIVE, sym, env.info.pendingResolutionPhase));
-resultInfo.pt.map(deferredAttr.new RecoveryDeferredTypeMap(AttrMode.CHECK, sym, env.info.pendingResolutionPhase));
+Type owntype = checkIdInternal(tree, site, sym, pt, env, resultInfo);
-return owntype;
+resultInfo.pt.map(deferredAttr.new RecoveryDeferredTypeMap(AttrMode.CHECK, sym, env.info.pendingResolutionPhase));
+return owntype;
+} else {
+return checkIdInternal(tree, site, sym, resultInfo.pt, env, resultInfo);
+}
 }
 Type checkIdInternal(JCTree tree,
 Type site,
 Symbol sym,
 owntype = capture(owntype); // capture "names as expressions"
 }
 break;
 case MTH: {
 owntype = checkMethod(site, sym,
-new ResultInfo(VAL, resultInfo.pt.getReturnType(), resultInfo.checkContext),
+new ResultInfo(resultInfo.pkind, resultInfo.pt.getReturnType(), resultInfo.checkContext),
 env, TreeInfo.args(env.tree), resultInfo.pt.getParameterTypes(),
 resultInfo.pt.getTypeArguments());
 break;
 }
 case PCK: case ERR:
 isSerializable(c) &&
 (c.flags() & Flags.ENUM) == 0 &&
 (c.flags() & ABSTRACT) == 0) {
 checkSerialVersionUID(tree, c);
 }
+if (allowTypeAnnos) {
 // Correctly organize the postions of the type annotations
 TypeAnnotations.organizeTypeAnnotationsBodies(this.syms, this.names, this.log, tree);
 // Check type annotations applicability rules
 validateTypeAnnotations(tree);
+}
 }
 // where
 /** get a diagnostic position for an attribute of Type t, or null if attribute missing */
 private DiagnosticPosition getDiagnosticPosition(JCClassDecl tree, Type t) {
 for(List<JCAnnotation> al = tree.mods.annotations; !al.isEmpty(); al = al.tail) {

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

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

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