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

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 /*
-* Copyright (c) 1999, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 import com.sun.tools.javac.comp.Resolve.ReferenceLookupResult.StaticKind;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.main.Option;
 import com.sun.tools.javac.resources.CompilerProperties.Errors;
 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
+import com.sun.tools.javac.resources.CompilerProperties.Warnings;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.tree.JCTree.JCMemberReference.ReferenceKind;
 import com.sun.tools.javac.tree.JCTree.JCPolyExpression.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.DefinedBy.Api;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticType;
+import com.sun.tools.javac.util.JCDiagnostic.Warning;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.BiPredicate;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 import javax.lang.model.element.ElementVisitor;
 public final boolean allowFunctionalInterfaceMostSpecific;
 public final boolean allowModules;
 public final boolean checkVarargsAccessAfterResolution;
 private final boolean compactMethodDiags;
 private final boolean allowLocalVariableTypeInference;
+private final boolean allowYieldStatement;
 final EnumSet<VerboseResolutionMode> verboseResolutionMode;
 WriteableScope polymorphicSignatureScope;
 protected Resolve(Context context) {
 infer = Infer.instance(context);
 finder = ClassFinder.instance(context);
 moduleFinder = ModuleFinder.instance(context);
 types = Types.instance(context);
 diags = JCDiagnostic.Factory.instance(context);
+Preview preview = Preview.instance(context);
 Source source = Source.instance(context);
 Options options = Options.instance(context);
 compactMethodDiags = options.isSet(Option.XDIAGS, "compact") ||
 options.isUnset(Option.XDIAGS) && options.isUnset("rawDiagnostics");
 verboseResolutionMode = VerboseResolutionMode.getVerboseResolutionMode(options);
 Target target = Target.instance(context);
 allowFunctionalInterfaceMostSpecific = Feature.FUNCTIONAL_INTERFACE_MOST_SPECIFIC.allowedInSource(source);
 allowLocalVariableTypeInference = Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source);
+allowYieldStatement = (!preview.isPreview(Feature.SWITCH_EXPRESSION) || preview.isEnabled()) &&
+Feature.SWITCH_EXPRESSION.allowedInSource(source);
 checkVarargsAccessAfterResolution =
 Feature.POST_APPLICABILITY_VARARGS_ACCESS_CHECK.allowedInSource(source);
 polymorphicSignatureScope = WriteableScope.create(syms.noSymbol);
 allowModules = Feature.MODULES.allowedInSource(source);
 }
 }
 public static class InapplicableMethodException extends RuntimeException {
 private static final long serialVersionUID = 0;
-JCDiagnostic diagnostic;
+transient JCDiagnostic diagnostic;
 InapplicableMethodException(JCDiagnostic diag) {
 this.diagnostic = diag;
 }
 return bestSoFar;
 }
 /** Find an unqualified identifier which matches a specified kind set.
+*  @param pos       position on which report warnings, if any;
+*                   null warnings should not be reported
 *  @param env       The current environment.
 *  @param name      The identifier's name.
 *  @param kind      Indicates the possible symbol kinds
 *                   (a subset of VAL, TYP, PCK).
 */
-Symbol findIdent(Env<AttrContext> env, Name name, KindSelector kind) {
+Symbol findIdent(DiagnosticPosition pos, Env<AttrContext> env, Name name, KindSelector kind) {
-return checkVarType(findIdentInternal(env, name, kind), name);
+return checkRestrictedType(pos, findIdentInternal(env, name, kind), name);
 }
 Symbol findIdentInternal(Env<AttrContext> env, Name name, KindSelector kind) {
 Symbol bestSoFar = typeNotFound;
 Symbol sym;
 return lookupPackage(env, name);
 else return bestSoFar;
 }
 /** Find an identifier in a package which matches a specified kind set.
+*  @param pos       position on which report warnings, if any;
+*                   null warnings should not be reported
 *  @param env       The current environment.
 *  @param name      The identifier's name.
 *  @param kind      Indicates the possible symbol kinds
 *                   (a nonempty subset of TYP, PCK).
 */
-Symbol findIdentInPackage(Env<AttrContext> env, TypeSymbol pck,
+Symbol findIdentInPackage(DiagnosticPosition pos,
+Env<AttrContext> env, TypeSymbol pck,
 Name name, KindSelector kind) {
-return checkVarType(findIdentInPackageInternal(env, pck, name, kind), name);
+return checkRestrictedType(pos, findIdentInPackageInternal(env, pck, name, kind), name);
 }
 Symbol findIdentInPackageInternal(Env<AttrContext> env, TypeSymbol pck,
 Name name, KindSelector kind) {
 Name fullname = TypeSymbol.formFullName(name, pck);
 Symbol bestSoFar = typeNotFound;
 if (kind.contains(KindSelector.TYP)) {
 RecoveryLoadClass recoveryLoadClass =
 allowModules && !kind.contains(KindSelector.PCK) &&
-!pck.exists() && !env.info.isSpeculative ?
+!pck.exists() && !env.info.attributionMode.isSpeculative ?
 doRecoveryLoadClass : noRecovery;
 Symbol sym = loadClass(env, fullname, recoveryLoadClass);
 if (sym.exists()) {
 // don't allow programs to use flatnames
 if (name == sym.name) return sym;
 }
 return bestSoFar;
 }
 /** Find an identifier among the members of a given type `site'.
+*  @param pos       position on which report warnings, if any;
+*                   null warnings should not be reported
 *  @param env       The current environment.
 *  @param site      The type containing the symbol to be found.
 *  @param name      The identifier's name.
 *  @param kind      Indicates the possible symbol kinds
 *                   (a subset of VAL, TYP).
 */
-Symbol findIdentInType(Env<AttrContext> env, Type site,
+Symbol findIdentInType(DiagnosticPosition pos,
+Env<AttrContext> env, Type site,
 Name name, KindSelector kind) {
-return checkVarType(findIdentInTypeInternal(env, site, name, kind), name);
+return checkRestrictedType(pos, findIdentInTypeInternal(env, site, name, kind), name);
 }
 Symbol findIdentInTypeInternal(Env<AttrContext> env, Type site,
 Name name, KindSelector kind) {
 Symbol bestSoFar = typeNotFound;
 else bestSoFar = bestOf(bestSoFar, sym);
 }
 return bestSoFar;
 }
-private Symbol checkVarType(Symbol bestSoFar, Name name) {
+private Symbol checkRestrictedType(DiagnosticPosition pos, Symbol bestSoFar, Name name) {
-if (allowLocalVariableTypeInference && name.equals(names.var) &&
+if (bestSoFar.kind == TYP || bestSoFar.kind == ABSENT_TYP) {
-(bestSoFar.kind == TYP || bestSoFar.kind == ABSENT_TYP)) {
+if (allowLocalVariableTypeInference && name.equals(names.var)) {
-bestSoFar = new BadVarTypeError();
+bestSoFar = new BadRestrictedTypeError(names.var);
+} else if (name.equals(names.yield)) {
+if (allowYieldStatement) {
+bestSoFar = new BadRestrictedTypeError(names.yield);
+} else if (pos != null) {
+log.warning(pos, Warnings.IllegalRefToRestrictedType(names.yield));
+}
+}
 }
 return bestSoFar;
 }
 /* ***************************************************************************
 *  @param kind      The set of admissible symbol kinds for the identifier.
 */
 Symbol resolveIdent(DiagnosticPosition pos, Env<AttrContext> env,
 Name name, KindSelector kind) {
 return accessBase(
-findIdent(env, name, kind),
+findIdent(pos, env, name, kind),
 pos, env.enclClass.sym.type, name, false);
 }
 /** Resolve an unqualified method identifier.
 *  @param pos       The position to use for error reporting.
 else
 return sym;
 }
 }
-class BadVarTypeError extends ResolveError {
+class BadRestrictedTypeError extends ResolveError {
-BadVarTypeError() {
+private final Name typeName;
-super(Kind.BAD_VAR, "bad var use");
+BadRestrictedTypeError(Name typeName) {
+super(Kind.BAD_RESTRICTED_TYPE, "bad var use");
+this.typeName = typeName;
 }
 @Override
 JCDiagnostic getDiagnostic(DiagnosticType dkind, DiagnosticPosition pos, Symbol location, Type site, Name name, List<Type> argtypes, List<Type> typeargtypes) {
-return diags.create(dkind, log.currentSource(), pos, "illegal.ref.to.var.type");
+return diags.create(dkind, log.currentSource(), pos, "illegal.ref.to.restricted.type", typeName);
 }
 }
 /**
 * InvalidSymbolError error class indicating that a symbol matching a

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 51047	860a3648c494
child 58679	9c3209ff7550