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

-:1cf5a53613ae
+:fa8be3ce18fc
 m.enclClass().flags_field |= DEFAULT;
 }
 Env<AttrContext> localEnv = methodEnv(tree, env);
-annotate.enterStart();
+DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());
 try {
-DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());
+// Compute the method type
-try {
+m.type = signature(m, tree.typarams, tree.params,
-// Compute the method type
+tree.restype, tree.recvparam,
-m.type = signature(m, tree.typarams, tree.params,
+tree.thrown,
-tree.restype, tree.recvparam,
+localEnv);
-tree.thrown,
-localEnv);
-} finally {
-deferredLintHandler.setPos(prevLintPos);
-}
-if (types.isSignaturePolymorphic(m)) {
-m.flags_field |= SIGNATURE_POLYMORPHIC;
-}
-// Set m.params
-ListBuffer<VarSymbol> params = new ListBuffer<VarSymbol>();
-JCVariableDecl lastParam = null;
-for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
-JCVariableDecl param = lastParam = l.head;
-params.append(Assert.checkNonNull(param.sym));
-}
-m.params = params.toList();
-// mark the method varargs, if necessary
-if (lastParam != null && (lastParam.mods.flags & Flags.VARARGS) != 0)
-m.flags_field |= Flags.VARARGS;
-localEnv.info.scope.leave();
-if (chk.checkUnique(tree.pos(), m, enclScope)) {
-enclScope.enter(m);
-}
-annotateLater(tree.mods.annotations, localEnv, m, tree.pos());
-// Visit the signature of the method. Note that
-// TypeAnnotate doesn't descend into the body.
-typeAnnotate(tree, localEnv, m, tree.pos());
-if (tree.defaultValue != null)
-annotateDefaultValueLater(tree.defaultValue, localEnv, m);
 } finally {
-annotate.enterDone();
+deferredLintHandler.setPos(prevLintPos);
 }
+if (types.isSignaturePolymorphic(m)) {
+m.flags_field |= SIGNATURE_POLYMORPHIC;
+}
+// Set m.params
+ListBuffer<VarSymbol> params = new ListBuffer<VarSymbol>();
+JCVariableDecl lastParam = null;
+for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
+JCVariableDecl param = lastParam = l.head;
+params.append(Assert.checkNonNull(param.sym));
+}
+m.params = params.toList();
+// mark the method varargs, if necessary
+if (lastParam != null && (lastParam.mods.flags & Flags.VARARGS) != 0)
+m.flags_field |= Flags.VARARGS;
+localEnv.info.scope.leave();
+if (chk.checkUnique(tree.pos(), m, enclScope)) {
+enclScope.enter(m);
+}
+annotateLater(tree.mods.annotations, localEnv, m, tree.pos());
+// Visit the signature of the method. Note that
+// TypeAnnotate doesn't descend into the body.
+typeAnnotate(tree, localEnv, m, tree.pos());
+if (tree.defaultValue != null)
+annotateDefaultValueLater(tree.defaultValue, localEnv, m);
 }
 /** Create a fresh environment for method bodies.
 *  @param tree     The method definition.
 *  @param env      The environment current outside of the method definition.
 (env.info.scope.owner.flags() & INTERFACE) != 0) {
 localEnv = env.dup(tree, env.info.dup());
 localEnv.info.staticLevel++;
 }
 DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());
-annotate.enterStart();
 try {
-try {
+if (TreeInfo.isEnumInit(tree)) {
-if (TreeInfo.isEnumInit(tree)) {
+attr.attribIdentAsEnumType(localEnv, (JCIdent)tree.vartype);
-attr.attribIdentAsEnumType(localEnv, (JCIdent)tree.vartype);
+} else {
-} else {
+attr.attribType(tree.vartype, localEnv);
-attr.attribType(tree.vartype, localEnv);
+if (TreeInfo.isReceiverParam(tree))
-if (TreeInfo.isReceiverParam(tree))
+checkReceiver(tree, localEnv);
-checkReceiver(tree, localEnv);
+}
-}
-} finally {
-deferredLintHandler.setPos(prevLintPos);
-}
-if ((tree.mods.flags & VARARGS) != 0) {
-//if we are entering a varargs parameter, we need to
-//replace its type (a plain array type) with the more
-//precise VarargsType --- we need to do it this way
-//because varargs is represented in the tree as a
-//modifier on the parameter declaration, and not as a
-//distinct type of array node.
-ArrayType atype = (ArrayType)tree.vartype.type.unannotatedType();
-tree.vartype.type = atype.makeVarargs();
-}
-Scope enclScope = enter.enterScope(env);
-VarSymbol v =
-new VarSymbol(0, tree.name, tree.vartype.type, enclScope.owner);
-v.flags_field = chk.checkFlags(tree.pos(), tree.mods.flags, v, tree);
-tree.sym = v;
-if (tree.init != null) {
-v.flags_field |= HASINIT;
-if ((v.flags_field & FINAL) != 0 &&
-needsLazyConstValue(tree.init)) {
-Env<AttrContext> initEnv = getInitEnv(tree, env);
-initEnv.info.enclVar = v;
-v.setLazyConstValue(initEnv(tree, initEnv), attr, tree);
-}
-}
-if (chk.checkUnique(tree.pos(), v, enclScope)) {
-chk.checkTransparentVar(tree.pos(), v, enclScope);
-enclScope.enter(v);
-}
-annotateLater(tree.mods.annotations, localEnv, v, tree.pos());
-typeAnnotate(tree.vartype, env, v, tree.pos());
-v.pos = tree.pos;
 } finally {
-annotate.enterDone();
+deferredLintHandler.setPos(prevLintPos);
 }
+if ((tree.mods.flags & VARARGS) != 0) {
+//if we are entering a varargs parameter, we need to
+//replace its type (a plain array type) with the more
+//precise VarargsType --- we need to do it this way
+//because varargs is represented in the tree as a
+//modifier on the parameter declaration, and not as a
+//distinct type of array node.
+ArrayType atype = (ArrayType)tree.vartype.type.unannotatedType();
+tree.vartype.type = atype.makeVarargs();
+}
+Scope enclScope = enter.enterScope(env);
+VarSymbol v =
+new VarSymbol(0, tree.name, tree.vartype.type, enclScope.owner);
+v.flags_field = chk.checkFlags(tree.pos(), tree.mods.flags, v, tree);
+tree.sym = v;
+if (tree.init != null) {
+v.flags_field |= HASINIT;
+if ((v.flags_field & FINAL) != 0 &&
+needsLazyConstValue(tree.init)) {
+Env<AttrContext> initEnv = getInitEnv(tree, env);
+initEnv.info.enclVar = v;
+v.setLazyConstValue(initEnv(tree, initEnv), attr, tree);
+}
+}
+if (chk.checkUnique(tree.pos(), v, enclScope)) {
+chk.checkTransparentVar(tree.pos(), v, enclScope);
+enclScope.enter(v);
+}
+annotateLater(tree.mods.annotations, localEnv, v, tree.pos());
+typeAnnotate(tree.vartype, env, v, tree.pos());
+v.pos = tree.pos;
 }
 // where
 void checkType(JCTree tree, Type type, String diag) {
 if (!tree.type.isErroneous() && !types.isSameType(tree.type, type)) {
 log.error(tree, diag, type, tree.type);
 ClassType ct = (ClassType)c.type;
 Env<AttrContext> env = typeEnvs.get(c);
 JCClassDecl tree = (JCClassDecl)env.tree;
 boolean wasFirst = isFirst;
 isFirst = false;
-JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
-DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());
 try {
-// Save class environment for later member enter (2) processing.
+annotate.enterStart();
-halfcompleted.append(env);
+JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
-// Mark class as not yet attributed.
+DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());
-c.flags_field |= UNATTRIBUTED;
+try {
+// Save class environment for later member enter (2) processing.
-// If this is a toplevel-class, make sure any preceding import
+halfcompleted.append(env);
-// clauses have been seen.
-if (c.owner.kind == PCK) {
+// Mark class as not yet attributed.
-memberEnter(env.toplevel, env.enclosing(TOPLEVEL));
+c.flags_field |= UNATTRIBUTED;
-todo.append(env);
-}
+// If this is a toplevel-class, make sure any preceding import
+// clauses have been seen.
-if (c.owner.kind == TYP)
+if (c.owner.kind == PCK) {
-c.owner.complete();
+memberEnter(env.toplevel, env.enclosing(TOPLEVEL));
+todo.append(env);
-// create an environment for evaluating the base clauses
+}
-Env<AttrContext> baseEnv = baseEnv(tree, env);
+if (c.owner.kind == TYP)
-if (tree.extending != null)
+c.owner.complete();
-typeAnnotate(tree.extending, baseEnv, sym, tree.pos());
-for (JCExpression impl : tree.implementing)
+// create an environment for evaluating the base clauses
-typeAnnotate(impl, baseEnv, sym, tree.pos());
+Env<AttrContext> baseEnv = baseEnv(tree, env);
-annotate.flush();
+if (tree.extending != null)
-// Determine supertype.
+typeAnnotate(tree.extending, baseEnv, sym, tree.pos());
-Type supertype =
+for (JCExpression impl : tree.implementing)
-(tree.extending != null)
+typeAnnotate(impl, baseEnv, sym, tree.pos());
-? attr.attribBase(tree.extending, baseEnv, true, false, true)
+annotate.flush();
-: ((tree.mods.flags & Flags.ENUM) != 0)
-? attr.attribBase(enumBase(tree.pos, c), baseEnv,
+// Determine supertype.
-true, false, false)
+Type supertype =
-: (c.fullname == names.java_lang_Object)
+(tree.extending != null)
-? Type.noType
+? attr.attribBase(tree.extending, baseEnv, true, false, true)
-: syms.objectType;
+: ((tree.mods.flags & Flags.ENUM) != 0)
-ct.supertype_field = modelMissingTypes(supertype, tree.extending, false);
+? attr.attribBase(enumBase(tree.pos, c), baseEnv,
+true, false, false)
-// Determine interfaces.
+: (c.fullname == names.java_lang_Object)
-ListBuffer<Type> interfaces = new ListBuffer<Type>();
+? Type.noType
-ListBuffer<Type> all_interfaces = null; // lazy init
+: syms.objectType;
-Set<Type> interfaceSet = new HashSet<Type>();
+ct.supertype_field = modelMissingTypes(supertype, tree.extending, false);
-List<JCExpression> interfaceTrees = tree.implementing;
-for (JCExpression iface : interfaceTrees) {
+// Determine interfaces.
-Type i = attr.attribBase(iface, baseEnv, false, true, true);
+ListBuffer<Type> interfaces = new ListBuffer<Type>();
-if (i.hasTag(CLASS)) {
+ListBuffer<Type> all_interfaces = null; // lazy init
-interfaces.append(i);
+Set<Type> interfaceSet = new HashSet<Type>();
-if (all_interfaces != null) all_interfaces.append(i);
+List<JCExpression> interfaceTrees = tree.implementing;
-chk.checkNotRepeated(iface.pos(), types.erasure(i), interfaceSet);
+for (JCExpression iface : interfaceTrees) {
-} else {
+Type i = attr.attribBase(iface, baseEnv, false, true, true);
-if (all_interfaces == null)
+if (i.hasTag(CLASS)) {
-all_interfaces = new ListBuffer<Type>().appendList(interfaces);
+interfaces.append(i);
-all_interfaces.append(modelMissingTypes(i, iface, true));
+if (all_interfaces != null) all_interfaces.append(i);
-}
+chk.checkNotRepeated(iface.pos(), types.erasure(i), interfaceSet);
-}
+} else {
-if ((c.flags_field & ANNOTATION) != 0) {
+if (all_interfaces == null)
-ct.interfaces_field = List.of(syms.annotationType);
+all_interfaces = new ListBuffer<Type>().appendList(interfaces);
-ct.all_interfaces_field = ct.interfaces_field;
+all_interfaces.append(modelMissingTypes(i, iface, true));
-}  else {
+}
-ct.interfaces_field = interfaces.toList();
+}
-ct.all_interfaces_field = (all_interfaces == null)
+if ((c.flags_field & ANNOTATION) != 0) {
-? ct.interfaces_field : all_interfaces.toList();
+ct.interfaces_field = List.of(syms.annotationType);
-}
+ct.all_interfaces_field = ct.interfaces_field;
+}  else {
-if (c.fullname == names.java_lang_Object) {
+ct.interfaces_field = interfaces.toList();
-if (tree.extending != null) {
+ct.all_interfaces_field = (all_interfaces == null)
-chk.checkNonCyclic(tree.extending.pos(),
+? ct.interfaces_field : all_interfaces.toList();
-supertype);
+}
-ct.supertype_field = Type.noType;
-}
+if (c.fullname == names.java_lang_Object) {
-else if (tree.implementing.nonEmpty()) {
+if (tree.extending != null) {
-chk.checkNonCyclic(tree.implementing.head.pos(),
+chk.checkNonCyclic(tree.extending.pos(),
-ct.interfaces_field.head);
+supertype);
-ct.interfaces_field = List.nil();
+ct.supertype_field = Type.noType;
 }
-}
+else if (tree.implementing.nonEmpty()) {
+chk.checkNonCyclic(tree.implementing.head.pos(),
-// Annotations.
+ct.interfaces_field.head);
-// In general, we cannot fully process annotations yet,  but we
+ct.interfaces_field = List.nil();
-// can attribute the annotation types and then check to see if the
+}
-// @Deprecated annotation is present.
+}
-attr.attribAnnotationTypes(tree.mods.annotations, baseEnv);
-if (hasDeprecatedAnnotation(tree.mods.annotations))
+// Annotations.
-c.flags_field |= DEPRECATED;
+// In general, we cannot fully process annotations yet,  but we
-annotateLater(tree.mods.annotations, baseEnv, c, tree.pos());
+// can attribute the annotation types and then check to see if the
-// class type parameters use baseEnv but everything uses env
+// @Deprecated annotation is present.
+attr.attribAnnotationTypes(tree.mods.annotations, baseEnv);
-chk.checkNonCyclicDecl(tree);
+if (hasDeprecatedAnnotation(tree.mods.annotations))
+c.flags_field |= DEPRECATED;
-attr.attribTypeVariables(tree.typarams, baseEnv);
+annotateLater(tree.mods.annotations, baseEnv, c, tree.pos());
-// Do this here, where we have the symbol.
+// class type parameters use baseEnv but everything uses env
-for (JCTypeParameter tp : tree.typarams)
-typeAnnotate(tp, baseEnv, sym, tree.pos());
+chk.checkNonCyclicDecl(tree);
-// Add default constructor if needed.
+attr.attribTypeVariables(tree.typarams, baseEnv);
-if ((c.flags() & INTERFACE) == 0 &&
+// Do this here, where we have the symbol.
-!TreeInfo.hasConstructors(tree.defs)) {
+for (JCTypeParameter tp : tree.typarams)
-List<Type> argtypes = List.nil();
+typeAnnotate(tp, baseEnv, sym, tree.pos());
-List<Type> typarams = List.nil();
-List<Type> thrown = List.nil();
+// Add default constructor if needed.
-long ctorFlags = 0;
+if ((c.flags() & INTERFACE) == 0 &&
-boolean based = false;
+!TreeInfo.hasConstructors(tree.defs)) {
-boolean addConstructor = true;
+List<Type> argtypes = List.nil();
-JCNewClass nc = null;
+List<Type> typarams = List.nil();
-if (c.name.isEmpty()) {
+List<Type> thrown = List.nil();
-nc = (JCNewClass)env.next.tree;
+long ctorFlags = 0;
-if (nc.constructor != null) {
+boolean based = false;
-addConstructor = nc.constructor.kind != ERR;
+boolean addConstructor = true;
-Type superConstrType = types.memberType(c.type,
+JCNewClass nc = null;
-nc.constructor);
+if (c.name.isEmpty()) {
-argtypes = superConstrType.getParameterTypes();
+nc = (JCNewClass)env.next.tree;
-typarams = superConstrType.getTypeArguments();
+if (nc.constructor != null) {
-ctorFlags = nc.constructor.flags() & VARARGS;
+addConstructor = nc.constructor.kind != ERR;
-if (nc.encl != null) {
+Type superConstrType = types.memberType(c.type,
-argtypes = argtypes.prepend(nc.encl.type);
+nc.constructor);
-based = true;
+argtypes = superConstrType.getParameterTypes();
+typarams = superConstrType.getTypeArguments();
+ctorFlags = nc.constructor.flags() & VARARGS;
+if (nc.encl != null) {
+argtypes = argtypes.prepend(nc.encl.type);
+based = true;
+}
+thrown = superConstrType.getThrownTypes();
 }
-thrown = superConstrType.getThrownTypes();
 }
-}
+if (addConstructor) {
-if (addConstructor) {
+MethodSymbol basedConstructor = nc != null ?
-MethodSymbol basedConstructor = nc != null ?
+(MethodSymbol)nc.constructor : null;
-(MethodSymbol)nc.constructor : null;
+JCTree constrDef = DefaultConstructor(make.at(tree.pos), c,
-JCTree constrDef = DefaultConstructor(make.at(tree.pos), c,
+basedConstructor,
-basedConstructor,
+typarams, argtypes, thrown,
-typarams, argtypes, thrown,
+ctorFlags, based);
-ctorFlags, based);
+tree.defs = tree.defs.prepend(constrDef);
-tree.defs = tree.defs.prepend(constrDef);
+}
 }
-}
+// enter symbols for 'this' into current scope.
-// enter symbols for 'this' into current scope.
+VarSymbol thisSym =
-VarSymbol thisSym =
+new VarSymbol(FINAL | HASINIT, names._this, c.type, c);
-new VarSymbol(FINAL | HASINIT, names._this, c.type, c);
+thisSym.pos = Position.FIRSTPOS;
-thisSym.pos = Position.FIRSTPOS;
+env.info.scope.enter(thisSym);
-env.info.scope.enter(thisSym);
+// if this is a class, enter symbol for 'super' into current scope.
-// if this is a class, enter symbol for 'super' into current scope.
+if ((c.flags_field & INTERFACE) == 0 &&
-if ((c.flags_field & INTERFACE) == 0 &&
+ct.supertype_field.hasTag(CLASS)) {
-ct.supertype_field.hasTag(CLASS)) {
+VarSymbol superSym =
-VarSymbol superSym =
+new VarSymbol(FINAL | HASINIT, names._super,
-new VarSymbol(FINAL | HASINIT, names._super,
+ct.supertype_field, c);
-ct.supertype_field, c);
+superSym.pos = Position.FIRSTPOS;
-superSym.pos = Position.FIRSTPOS;
+env.info.scope.enter(superSym);
-env.info.scope.enter(superSym);
+}
-}
+// check that no package exists with same fully qualified name,
-// check that no package exists with same fully qualified name,
+// but admit classes in the unnamed package which have the same
-// but admit classes in the unnamed package which have the same
+// name as a top-level package.
-// name as a top-level package.
+if (checkClash &&
-if (checkClash &&
+c.owner.kind == PCK && c.owner != syms.unnamedPackage &&
-c.owner.kind == PCK && c.owner != syms.unnamedPackage &&
+reader.packageExists(c.fullname)) {
-reader.packageExists(c.fullname)) {
+log.error(tree.pos, "clash.with.pkg.of.same.name", Kinds.kindName(sym), c);
-log.error(tree.pos, "clash.with.pkg.of.same.name", Kinds.kindName(sym), c);
+}
-}
+if (c.owner.kind == PCK && (c.flags_field & PUBLIC) == 0 &&
-if (c.owner.kind == PCK && (c.flags_field & PUBLIC) == 0 &&
+!env.toplevel.sourcefile.isNameCompatible(c.name.toString(),JavaFileObject.Kind.SOURCE)) {
-!env.toplevel.sourcefile.isNameCompatible(c.name.toString(),JavaFileObject.Kind.SOURCE)) {
+c.flags_field |= AUXILIARY;
-c.flags_field |= AUXILIARY;
+}
-}
+} catch (CompletionFailure ex) {
-} catch (CompletionFailure ex) {
+chk.completionError(tree.pos(), ex);
-chk.completionError(tree.pos(), ex);
+} finally {
+deferredLintHandler.setPos(prevLintPos);
+log.useSource(prev);
+}
+// Enter all member fields and methods of a set of half completed
+// classes in a second phase.
+if (wasFirst) {
+try {
+while (halfcompleted.nonEmpty()) {
+Env<AttrContext> toFinish = halfcompleted.next();
+finish(toFinish);
+if (allowTypeAnnos) {
+typeAnnotations.organizeTypeAnnotationsSignatures(toFinish, (JCClassDecl)toFinish.tree);
+typeAnnotations.validateTypeAnnotationsSignatures(toFinish, (JCClassDecl)toFinish.tree);
+}
+}
+} finally {
+isFirst = true;
+}
+}
 } finally {
-deferredLintHandler.setPos(prevLintPos);
+annotate.enterDone();
-log.useSource(prev);
-}
-// Enter all member fields and methods of a set of half completed
-// classes in a second phase.
-if (wasFirst) {
-try {
-while (halfcompleted.nonEmpty()) {
-Env<AttrContext> toFinish = halfcompleted.next();
-finish(toFinish);
-if (allowTypeAnnos) {
-typeAnnotations.organizeTypeAnnotationsSignatures(toFinish, (JCClassDecl)toFinish.tree);
-typeAnnotations.validateTypeAnnotationsSignatures(toFinish, (JCClassDecl)toFinish.tree);
-}
-}
-} finally {
-isFirst = true;
-}
 }
 }
 /*
 * If the symbol is non-null, attach the type annotation to it.

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

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

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