jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java

equal deleted inserted replaced

-:27045478cf23
+:603f0c93d5c9
 typeEnvs = TypeEnvs.instance(context);
 Options options = Options.instance(context);
 Source source = Source.instance(context);
-allowGenerics = source.allowGenerics();
-allowVarargs = source.allowVarargs();
-allowEnums = source.allowEnums();
-allowBoxing = source.allowBoxing();
-allowCovariantReturns = source.allowCovariantReturns();
-allowAnonOuterThis = source.allowAnonOuterThis();
 allowStringsInSwitch = source.allowStringsInSwitch();
 allowPoly = source.allowPoly();
 allowTypeAnnos = source.allowTypeAnnotations();
 allowLambda = source.allowLambda();
 allowDefaultMethods = source.allowDefaultMethods();
 /** Switch: support type annotations.
 */
 boolean allowTypeAnnos;
-/** Switch: support generics?
-*/
-boolean allowGenerics;
-/** Switch: allow variable-arity methods.
-*/
-boolean allowVarargs;
-/** Switch: support enums?
-*/
-boolean allowEnums;
-/** Switch: support boxing and unboxing?
-*/
-boolean allowBoxing;
-/** Switch: support covariant result types?
-*/
-boolean allowCovariantReturns;
 /** Switch: support lambda expressions ?
 */
 boolean allowLambda;
 /** Switch: support default methods ?
 boolean allowDefaultMethods;
 /** Switch: static interface methods enabled?
 */
 boolean allowStaticInterfaceMethods;
-/** Switch: allow references to surrounding object from anonymous
-* objects during constructor call?
-*/
-boolean allowAnonOuterThis;
 /** Switch: generates a warning if diamond can be safely applied
 *  to a given new expression
 */
 boolean findDiamonds;
 if (t.getUpperBound() == null) {
 log.error(tree.pos(), "illegal.forward.ref");
 return types.createErrorType(t);
 }
 } else {
-t = chk.checkClassType(tree.pos(), t, checkExtensible|!allowGenerics);
+t = chk.checkClassType(tree.pos(), t, checkExtensible);
 }
 if (interfaceExpected && (t.tsym.flags() & INTERFACE) == 0) {
 log.error(tree.pos(), "intf.expected.here");
 // return errType is necessary since otherwise there might
 // be undetected cycles which cause attribution to loop
 Env<AttrContext> switchEnv =
 env.dup(tree, env.info.dup(env.info.scope.dup()));
 try {
-boolean enumSwitch =
+boolean enumSwitch = (seltype.tsym.flags() & Flags.ENUM) != 0;
-allowEnums &&
-(seltype.tsym.flags() & Flags.ENUM) != 0;
 boolean stringSwitch = false;
 if (types.isSameType(seltype, syms.stringType)) {
 if (allowStringsInSwitch) {
 stringSwitch = true;
 } else {
 Type thentype, Type elsetype) {
 // If same type, that is the result
 if (types.isSameType(thentype, elsetype))
 return thentype.baseType();
-Type thenUnboxed = (!allowBoxing || thentype.isPrimitive())
+Type thenUnboxed = (thentype.isPrimitive())
 ? thentype : types.unboxedType(thentype);
-Type elseUnboxed = (!allowBoxing || elsetype.isPrimitive())
+Type elseUnboxed = (elsetype.isPrimitive())
 ? elsetype : types.unboxedType(elsetype);
 // Otherwise, if both arms can be converted to a numeric
 // type, return the least numeric type that fits both arms
 // (i.e. return larger of the two, or return int if one
 }
 }
 }
 // Those were all the cases that could result in a primitive
-if (allowBoxing) {
+if (thentype.isPrimitive())
-if (thentype.isPrimitive())
+thentype = types.boxedClass(thentype).type;
-thentype = types.boxedClass(thentype).type;
+if (elsetype.isPrimitive())
-if (elsetype.isPrimitive())
+elsetype = types.boxedClass(elsetype).type;
-elsetype = types.boxedClass(elsetype).type;
-}
 if (types.isSubtype(thentype, elsetype))
 return elsetype.baseType();
 if (types.isSubtype(elsetype, thentype))
 return thentype.baseType();
-if (!allowBoxing || thentype.hasTag(VOID) || elsetype.hasTag(VOID)) {
+if (thentype.hasTag(VOID) || elsetype.hasTag(VOID)) {
 log.error(pos, "neither.conditional.subtype",
 thentype, elsetype);
 return thentype.baseType();
 }
 site.tsym);
 }
 // if we're calling a java.lang.Enum constructor,
 // prefix the implicit String and int parameters
-if (site.tsym == syms.enumSym && allowEnums)
+if (site.tsym == syms.enumSym)
 argtypes = argtypes.prepend(syms.intType).prepend(syms.stringType);
 // Resolve the called constructor under the assumption
 // that we are referring to a superclass instance of the
 // current instance (JLS ???).
 chk.validate(tree.typeargs, localEnv);
 }
 //where
 Type adjustMethodReturnType(Type qualifierType, Name methodName, List<Type> argtypes, Type restype) {
-if (allowCovariantReturns &&
+if (methodName == names.clone && types.isArray(qualifierType)) {
-methodName == names.clone &&
-types.isArray(qualifierType)) {
 // as a special case, array.clone() has a result that is
 // the same as static type of the array being cloned
 return qualifierType;
-} else if (allowGenerics &&
+} else if (methodName == names.getClass && argtypes.isEmpty()) {
-methodName == names.getClass &&
-argtypes.isEmpty()) {
 // as a special case, x.getClass() has type Class<? extends |X|>
 return new ClassType(restype.getEnclosingType(),
 List.<Type>of(new WildcardType(types.erasure(qualifierType),
 BoundKind.EXTENDS,
 syms.boundClass,
 chk.checkRefTypes(tree.typeargs, typeargtypesbuf.toList());
 // If we have made no mistakes in the class type...
 if (clazztype.hasTag(CLASS)) {
 // Enums may not be instantiated except implicitly
-if (allowEnums &&
+if ((clazztype.tsym.flags_field & Flags.ENUM) != 0 &&
-(clazztype.tsym.flags_field&Flags.ENUM) != 0 &&
 (!env.tree.hasTag(VARDEF) ||
-(((JCVariableDecl) env.tree).mods.flags&Flags.ENUM) == 0 ||
+(((JCVariableDecl) env.tree).mods.flags & Flags.ENUM) == 0 ||
 ((JCVariableDecl) env.tree).init != tree))
 log.error(tree.pos(), "enum.cant.be.instantiated");
 // Check that class is not abstract
 if (cdef == null &&
 (clazztype.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {
 // Find environment in which identifier is defined.
 while (symEnv.outer != null &&
 !sym.isMemberOf(symEnv.enclClass.sym, types)) {
 if ((symEnv.enclClass.sym.flags() & NOOUTERTHIS) != 0)
-noOuterThisPath = !allowAnonOuterThis;
+noOuterThisPath = false;
 symEnv = symEnv.outer;
 }
 }
 // If symbol is a variable, ...
 return rs.resolveSelf(pos, env, site.tsym, name);
 } else if (name == names._class) {
 // In this case, we have already made sure in
 // visitSelect that qualifier expression is a type.
 Type t = syms.classType;
-List<Type> typeargs = allowGenerics
+List<Type> typeargs = List.of(types.erasure(site));
-? List.of(types.erasure(site))
-: List.<Type>nil();
 t = new ClassType(t.getEnclosingType(), typeargs, t.tsym);
 return new VarSymbol(
 STATIC | PUBLIC | FINAL, names._class, t, site.tsym);
 } else {
 // We are seeing a plain identifier as selector.
 case VAR:
 VarSymbol v = (VarSymbol)sym;
 // Test (4): if symbol is an instance field of a raw type,
 // which is being assigned to, issue an unchecked warning if
 // its type changes under erasure.
-if (allowGenerics &&
+if (resultInfo.pkind == VAR &&
-resultInfo.pkind == VAR &&
 v.owner.kind == TYP &&
 (v.flags() & STATIC) == 0 &&
 (site.hasTag(CLASS) || site.hasTag(TYPEVAR))) {
 Type s = types.asOuterSuper(site, v.owner);
 if (s != null &&
 final List<JCExpression> argtrees,
 List<Type> argtypes,
 List<Type> typeargtypes) {
 // Test (5): if symbol is an instance method of a raw type, issue
 // an unchecked warning if its argument types change under erasure.
-if (allowGenerics &&
+if ((sym.flags() & STATIC) == 0 &&
-(sym.flags() & STATIC) == 0 &&
 (site.hasTag(CLASS) || site.hasTag(TYPEVAR))) {
 Type s = types.asOuterSuper(site, sym.owner);
 if (s != null && s.isRaw() &&
 !types.isSameTypes(sym.type.getParameterTypes(),
 sym.erasure(types).getParameterTypes())) {

changeset 25445	603f0c93d5c9
parent 25443	9187d77f2c64
child 25844	48eab270456c