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

-:ddec8c712e85
+:f5b5112ee1cc
 }
 // Attribute clazz expression and store
 // symbol + type back into the attributed tree.
 Type clazztype = attribType(clazz, env);
-Pair<Scope,Scope> mapping = getSyntheticScopeMapping(clazztype, cdef != null);
+Pair<Scope,Scope> mapping = getSyntheticScopeMapping(clazztype);
 clazztype = chk.checkDiamond(tree, clazztype);
 chk.validate(clazz, localEnv);
 if (tree.encl != null) {
 // We have to work in this case to store
 // symbol + type back into the attributed tree.
 JCNewClass tree,
 Type clazztype,
 Pair<Scope, Scope> mapping,
 List<Type> argtypes,
 List<Type> typeargtypes) {
-if (clazztype.isErroneous() || mapping == erroneousMapping) {
+if (clazztype.isErroneous() ||
+clazztype.isInterface() ||
+mapping == erroneousMapping) {
 //if the type of the instance creation expression is erroneous,
-//or something prevented us to form a valid mapping, return the
+//or if it's an interface, or if something prevented us to form a valid
-//(possibly erroneous) type unchanged
+//mapping, return the (possibly erroneous) type unchanged
 return clazztype;
 }
-else if (clazztype.isInterface()) {
-//if the type of the instance creation expression is an interface
+//dup attribution environment and augment the set of inference variables
-//skip the method resolution step (JLS 15.12.2.7). The type to be
+Env<AttrContext> localEnv = env.dup(tree);
-//inferred is of the kind <X1,X2, ... Xn>C<X1,X2, ... Xn>
+localEnv.info.tvars = clazztype.tsym.type.getTypeArguments();
-clazztype = new ForAll(clazztype.tsym.type.allparams(), clazztype.tsym.type) {
-@Override
+//if the type of the instance creation expression is a class type
-public List<Type> getConstraints(TypeVar tv, ConstraintKind ck) {
+//apply method resolution inference (JLS 15.12.2.7). The return type
-switch (ck) {
+//of the resolved constructor will be a partially instantiated type
-case EXTENDS: return types.getBounds(tv);
+((ClassSymbol) clazztype.tsym).members_field = mapping.snd;
-default: return List.nil();
+Symbol constructor;
-}
+try {
-}
+constructor = rs.resolveDiamond(tree.pos(),
-@Override
+localEnv,
-public Type inst(List<Type> inferred, Types types) throws Infer.NoInstanceException {
+clazztype.tsym.type,
-// check that inferred bounds conform to their bounds
+argtypes,
-infer.checkWithinBounds(tvars,
+typeargtypes);
-types.subst(tvars, tvars, inferred), Warner.noWarnings);
+} finally {
-return super.inst(inferred, types);
+((ClassSymbol) clazztype.tsym).members_field = mapping.fst;
 }
-};
+if (constructor.kind == MTH) {
+ClassType ct = new ClassType(clazztype.getEnclosingType(),
+clazztype.tsym.type.getTypeArguments(),
+clazztype.tsym);
+clazztype = checkMethod(ct,
+constructor,
+localEnv,
+tree.args,
+argtypes,
+typeargtypes,
+localEnv.info.varArgs).getReturnType();
 } else {
-//if the type of the instance creation expression is a class type
+clazztype = syms.errType;
-//apply method resolution inference (JLS 15.12.2.7). The return type
+}
-//of the resolved constructor will be a partially instantiated type
-((ClassSymbol) clazztype.tsym).members_field = mapping.snd;
-Symbol constructor;
-try {
-constructor = rs.resolveDiamond(tree.pos(),
-env,
-clazztype.tsym.type,
-argtypes,
-typeargtypes);
-} finally {
-((ClassSymbol) clazztype.tsym).members_field = mapping.fst;
-}
-if (constructor.kind == MTH) {
-ClassType ct = new ClassType(clazztype.getEnclosingType(),
-clazztype.tsym.type.getTypeArguments(),
-clazztype.tsym);
-clazztype = checkMethod(ct,
-constructor,
-env,
-tree.args,
-argtypes,
-typeargtypes,
-env.info.varArgs).getReturnType();
-} else {
-clazztype = syms.errType;
-}
-}
 if (clazztype.tag == FORALL && !pt.isErroneous()) {
 //if the resolved constructor's return type has some uninferred
 //type-variables, infer them using the expected type and declared
 //bounds (JLS 15.12.2.8).
 try {
 *  the synthetic scope is added a generic constructor of the kind:
 *  <X,Y>Foo<X,Y>(X x, Y y). This is crucial in order to enable diamond
 *  inference. The inferred return type of the synthetic constructor IS
 *  the inferred type for the diamond operator.
 */
-private Pair<Scope, Scope> getSyntheticScopeMapping(Type ctype, boolean overrideProtectedAccess) {
+private Pair<Scope, Scope> getSyntheticScopeMapping(Type ctype) {
 if (ctype.tag != CLASS) {
 return erroneousMapping;
 }
 Pair<Scope, Scope> mapping =
 new Pair<Scope, Scope>(ctype.tsym.members(), new Scope(ctype.tsym));
-List<Type> typevars = ctype.tsym.type.getTypeArguments();
+//for each constructor in the original scope, create a synthetic constructor
+//whose return type is the type of the class in which the constructor is
+//declared, and insert it into the new scope.
 for (Scope.Entry e = mapping.fst.lookup(names.init);
 e.scope != null;
 e = e.next()) {
-MethodSymbol newConstr = (MethodSymbol) e.sym.clone(ctype.tsym);
+Type synthRestype = new ClassType(ctype.getEnclosingType(),
-if (overrideProtectedAccess && (newConstr.flags() & PROTECTED) != 0) {
+ctype.tsym.type.getTypeArguments(),
-//make protected constructor public (this is required for
+ctype.tsym);
-//anonymous inner class creation expressions using diamond)
+MethodSymbol synhConstr = new MethodSymbol(e.sym.flags(),
-newConstr.flags_field |= PUBLIC;
+names.init,
-newConstr.flags_field &= ~PROTECTED;
+types.createMethodTypeWithReturn(e.sym.type, synthRestype),
-}
+e.sym.owner);
-newConstr.name = names.init;
+mapping.snd.enter(synhConstr);
-List<Type> oldTypeargs = List.nil();
-if (newConstr.type.tag == FORALL) {
-oldTypeargs = ((ForAll) newConstr.type).tvars;
-}
-newConstr.type = new MethodType(newConstr.type.getParameterTypes(),
-new ClassType(ctype.getEnclosingType(), ctype.tsym.type.getTypeArguments(), ctype.tsym),
-newConstr.type.getThrownTypes(),
-syms.methodClass);
-newConstr.type = new ForAll(typevars.prependList(oldTypeargs), newConstr.type);
-mapping.snd.enter(newConstr);
 }
 return mapping;
 }
 private final Pair<Scope,Scope> erroneousMapping = new Pair<Scope,Scope>(null, null);

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