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

-:4932bb04c4b8
+:4ce8148ffc4f
 private final Types types;
 private final JCDiagnostic.Factory diags;
 private final Source source;
 private final Target target;
 private final DeferredLintHandler deferredLintHandler;
+private final Lint lint;
 public static MemberEnter instance(Context context) {
 MemberEnter instance = context.get(memberEnterKey);
 if (instance == null)
 instance = new MemberEnter(context);
 types = Types.instance(context);
 diags = JCDiagnostic.Factory.instance(context);
 source = Source.instance(context);
 target = Target.instance(context);
 deferredLintHandler = DeferredLintHandler.instance(context);
+lint = Lint.instance(context);
 allowTypeAnnos = source.allowTypeAnnotations();
 }
 /** Switch: support type annotations.
 */
 p = p.owner;
 }
 }
 // process package annotations
-annotateLater(tree.packageAnnotations, env, tree.packge);
+annotateLater(tree.packageAnnotations, env, tree.packge, null);
-DeferredLintHandler prevLintHandler = chk.setDeferredLintHandler(DeferredLintHandler.immediateHandler);
+DiagnosticPosition prevLintPos = deferredLintHandler.immediate();
+Lint prevLint = chk.setLint(lint);
 try {
 // Import-on-demand java.lang.
 importAll(tree.pos, reader.enterPackage(names.java_lang), env);
 // Process all import clauses.
 memberEnter(tree.defs, env);
 } finally {
-chk.setDeferredLintHandler(prevLintHandler);
+chk.setLint(prevLint);
+deferredLintHandler.setPos(prevLintPos);
 }
 }
 // process the non-static imports and the static imports of types.
 public void visitImport(JCImport tree) {
 m.enclClass().flags_field |= DEFAULT;
 }
 Env<AttrContext> localEnv = methodEnv(tree, env);
-DeferredLintHandler prevLintHandler =
+DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());
-chk.setDeferredLintHandler(deferredLintHandler.setPos(tree.pos()));
 try {
 // Compute the method type
 m.type = signature(m, tree.typarams, tree.params,
 tree.restype, tree.recvparam,
 tree.thrown,
 localEnv);
 } finally {
-chk.setDeferredLintHandler(prevLintHandler);
+deferredLintHandler.setPos(prevLintPos);
 }
 if (types.isSignaturePolymorphic(m)) {
 m.flags_field |= SIGNATURE_POLYMORPHIC;
 }
 localEnv.info.scope.leave();
 if (chk.checkUnique(tree.pos(), m, enclScope)) {
 enclScope.enter(m);
 }
-annotateLater(tree.mods.annotations, localEnv, 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);
+typeAnnotate(tree, localEnv, m, tree.pos());
 if (tree.defaultValue != null)
 annotateDefaultValueLater(tree.defaultValue, localEnv, m);
 }
 if ((tree.mods.flags & STATIC) != 0 ||
 (env.info.scope.owner.flags() & INTERFACE) != 0) {
 localEnv = env.dup(tree, env.info.dup());
 localEnv.info.staticLevel++;
 }
-DeferredLintHandler prevLintHandler =
+DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());
-chk.setDeferredLintHandler(deferredLintHandler.setPos(tree.pos()));
 try {
 if (TreeInfo.isEnumInit(tree)) {
 attr.attribIdentAsEnumType(localEnv, (JCIdent)tree.vartype);
 } else {
 // Make sure type annotations are processed.
 // But we don't have a symbol to attach them to yet - use null.
-typeAnnotate(tree.vartype, env, null);
+typeAnnotate(tree.vartype, env, null, tree.pos());
 attr.attribType(tree.vartype, localEnv);
 if (tree.nameexpr != null) {
 attr.attribExpr(tree.nameexpr, localEnv);
 MethodSymbol m = localEnv.enclMethod.sym;
 if (m.isConstructor()) {
 checkType(tree.nameexpr, m.owner.type, "incorrect.receiver.name");
 }
 }
 }
 } finally {
-chk.setDeferredLintHandler(prevLintHandler);
+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
 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.init);
+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);
+annotateLater(tree.mods.annotations, localEnv, v, tree.pos());
-typeAnnotate(tree.vartype, env, v);
+typeAnnotate(tree.vartype, env, v, tree.pos());
 annotate.flush();
 v.pos = tree.pos;
 }
 // where
 void checkType(JCTree tree, Type type, String diag) {
 public void visitNewClass(JCNewClass that) {
 result = false;
 }
 @Override
+public void visitNewArray(JCNewArray that) {
+result = false;
+}
+@Override
 public void visitLambda(JCLambda that) {
 result = false;
 }
 @Override
 public void visitReference(JCMemberReference that) {
+result = false;
+}
+@Override
+public void visitApply(JCMethodInvocation that) {
 result = false;
 }
 @Override
 public void visitSelect(JCFieldAccess tree) {
 *********************************************************************/
 /** Queue annotations for later processing. */
 void annotateLater(final List<JCAnnotation> annotations,
 final Env<AttrContext> localEnv,
-final Symbol s) {
+final Symbol s,
+final DiagnosticPosition deferPos) {
 if (annotations.isEmpty()) {
 return;
 }
 if (s.kind != PCK) {
 s.resetAnnotations(); // mark Annotations as incomplete for now
 @Override
 public void enterAnnotation() {
 Assert.check(s.kind == PCK || s.annotationsPendingCompletion());
 JavaFileObject prev = log.useSource(localEnv.toplevel.sourcefile);
+DiagnosticPosition prevLintPos =
+deferPos != null
+? deferredLintHandler.setPos(deferPos)
+: deferredLintHandler.immediate();
+Lint prevLint = deferPos != null ? null : chk.setLint(lint);
 try {
 if (s.hasAnnotations() &&
 annotations.nonEmpty())
 log.error(annotations.head.pos,
 "already.annotated",
 kindName(s), s);
 actualEnterAnnotations(annotations, localEnv, s);
 } finally {
+if (prevLint != null)
+chk.setLint(prevLint);
+deferredLintHandler.setPos(prevLintPos);
 log.useSource(prev);
 }
 }
 });
 }
 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.
 halfcompleted.append(env);
 // Mark class as not yet attributed.
 // create an environment for evaluating the base clauses
 Env<AttrContext> baseEnv = baseEnv(tree, env);
 if (tree.extending != null)
-typeAnnotate(tree.extending, baseEnv, sym);
+typeAnnotate(tree.extending, baseEnv, sym, tree.pos());
 for (JCExpression impl : tree.implementing)
-typeAnnotate(impl, baseEnv, sym);
+typeAnnotate(impl, baseEnv, sym, tree.pos());
 annotate.flush();
 // Determine supertype.
 Type supertype =
 (tree.extending != null)
 // 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))
 c.flags_field |= DEPRECATED;
-annotateLater(tree.mods.annotations, baseEnv, c);
+annotateLater(tree.mods.annotations, baseEnv, c, tree.pos());
 // class type parameters use baseEnv but everything uses env
 chk.checkNonCyclicDecl(tree);
 attr.attribTypeVariables(tree.typarams, baseEnv);
 // Do this here, where we have the symbol.
 for (JCTypeParameter tp : tree.typarams)
-typeAnnotate(tp, baseEnv, sym);
+typeAnnotate(tp, baseEnv, sym, tree.pos());
 annotate.flush();
 // Add default constructor if needed.
 if ((c.flags() & INTERFACE) == 0 &&
 !TreeInfo.hasConstructors(tree.defs)) {
 c.flags_field |= AUXILIARY;
 }
 } catch (CompletionFailure 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.
 s.appendTypeAttributesWithCompletion(
 annotate.new AnnotateRepeatedContext<Attribute.TypeCompound>(env, annotated, pos, log, true));
 }
 }
-public void typeAnnotate(final JCTree tree, final Env<AttrContext> env, final Symbol sym) {
+public void typeAnnotate(final JCTree tree, final Env<AttrContext> env, final Symbol sym, DiagnosticPosition deferPos) {
 if (allowTypeAnnos) {
-tree.accept(new TypeAnnotate(env, sym));
+tree.accept(new TypeAnnotate(env, sym, deferPos));
 }
 }
 /**
 * We need to use a TreeScanner, because it is not enough to visit the top-level
 * annotations. We also need to visit type arguments, etc.
 */
 private class TypeAnnotate extends TreeScanner {
 private Env<AttrContext> env;
 private Symbol sym;
+private DiagnosticPosition deferPos;
-public TypeAnnotate(final Env<AttrContext> env, final Symbol sym) {
+public TypeAnnotate(final Env<AttrContext> env, final Symbol sym, DiagnosticPosition deferPos) {
 this.env = env;
 this.sym = sym;
+this.deferPos = deferPos;
 }
 void annotateTypeLater(final List<JCAnnotation> annotations) {
 if (annotations.isEmpty()) {
 return;
 }
+final DiagnosticPosition deferPos = this.deferPos;
 annotate.normal(new Annotate.Annotator() {
 @Override
 public String toString() {
 return "type annotate " + annotations + " onto " + sym + " in " + sym.owner;
 }
 @Override
 public void enterAnnotation() {
 JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
+DiagnosticPosition prevLintPos = null;
+if (deferPos != null) {
+prevLintPos = deferredLintHandler.setPos(deferPos);
+}
 try {
 actualEnterTypeAnnotations(annotations, env, sym);
 } finally {
+if (prevLintPos != null)
+deferredLintHandler.setPos(prevLintPos);
 log.useSource(prev);
 }
 }
 });
 }
 // scan(tree.body);
 }
 @Override
 public void visitVarDef(final JCVariableDecl tree) {
-if (sym != null && sym.kind == Kinds.VAR) {
+DiagnosticPosition prevPos = deferPos;
-// Don't visit a parameter once when the sym is the method
+deferPos = tree.pos();
-// and once when the sym is the parameter.
+try {
-scan(tree.mods);
+if (sym != null && sym.kind == Kinds.VAR) {
-scan(tree.vartype);
+// Don't visit a parameter once when the sym is the method
-}
+// and once when the sym is the parameter.
-scan(tree.init);
+scan(tree.mods);
+scan(tree.vartype);
+}
+scan(tree.init);
+} finally {
+deferPos = prevPos;
+}
 }
 @Override
 public void visitClassDef(JCClassDecl tree) {
 // We can only hit a classdef if it is declared within

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