| /* |
| * Copyright (c) 2015, 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 |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.tools.javac.comp; |
| |
| import com.sun.source.tree.LambdaExpressionTree.BodyKind; |
| import com.sun.tools.javac.code.Flags; |
| import com.sun.tools.javac.code.Symbol; |
| import com.sun.tools.javac.code.Symtab; |
| import com.sun.tools.javac.code.Type; |
| import com.sun.tools.javac.code.Types.FunctionDescriptorLookupError; |
| import com.sun.tools.javac.comp.Attr.ResultInfo; |
| import com.sun.tools.javac.comp.Attr.TargetInfo; |
| import com.sun.tools.javac.comp.Check.CheckContext; |
| import com.sun.tools.javac.comp.DeferredAttr.AttrMode; |
| import com.sun.tools.javac.comp.DeferredAttr.DeferredAttrContext; |
| import com.sun.tools.javac.comp.DeferredAttr.DeferredType; |
| import com.sun.tools.javac.comp.DeferredAttr.DeferredTypeCompleter; |
| import com.sun.tools.javac.comp.DeferredAttr.LambdaReturnScanner; |
| import com.sun.tools.javac.comp.Infer.PartiallyInferredMethodType; |
| import com.sun.tools.javac.comp.Resolve.MethodResolutionPhase; |
| import com.sun.tools.javac.tree.JCTree; |
| import com.sun.tools.javac.tree.JCTree.JCConditional; |
| import com.sun.tools.javac.tree.JCTree.JCExpression; |
| import com.sun.tools.javac.tree.JCTree.JCLambda; |
| import com.sun.tools.javac.tree.JCTree.JCLambda.ParameterKind; |
| import com.sun.tools.javac.tree.JCTree.JCMemberReference; |
| import com.sun.tools.javac.tree.JCTree.JCMethodInvocation; |
| import com.sun.tools.javac.tree.JCTree.JCNewClass; |
| import com.sun.tools.javac.tree.JCTree.JCParens; |
| import com.sun.tools.javac.tree.JCTree.JCReturn; |
| import com.sun.tools.javac.tree.TreeCopier; |
| import com.sun.tools.javac.tree.TreeInfo; |
| import com.sun.tools.javac.util.Assert; |
| import com.sun.tools.javac.util.Context; |
| import com.sun.tools.javac.util.DiagnosticSource; |
| import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition; |
| import com.sun.tools.javac.util.List; |
| import com.sun.tools.javac.util.ListBuffer; |
| import com.sun.tools.javac.util.Log; |
| |
| import java.util.HashMap; |
| import java.util.LinkedHashMap; |
| import java.util.Map; |
| import java.util.Optional; |
| import java.util.function.Function; |
| import java.util.function.Supplier; |
| |
| import static com.sun.tools.javac.code.TypeTag.DEFERRED; |
| import static com.sun.tools.javac.code.TypeTag.FORALL; |
| import static com.sun.tools.javac.code.TypeTag.METHOD; |
| import static com.sun.tools.javac.code.TypeTag.VOID; |
| |
| /** |
| * This class performs attribution of method/constructor arguments when target-typing is enabled |
| * (source >= 8); for each argument that is potentially a poly expression, this class builds |
| * a rich representation (see {@link ArgumentType} which can then be used for performing fast overload |
| * checks without requiring multiple attribution passes over the same code. |
| * |
| * The attribution strategy for a given method/constructor argument A is as follows: |
| * |
| * - if A is potentially a poly expression (i.e. diamond instance creation expression), a speculative |
| * pass over A is performed; the results of such speculative attribution are then saved in a special |
| * type, so that enclosing overload resolution can be carried by simply checking compatibility against the |
| * type determined during this speculative pass. |
| * |
| * - if A is a standalone expression, regular atributtion takes place. |
| * |
| * To minimize the speculative work, a cache is used, so that already computed argument types |
| * associated with a given unique source location are never recomputed multiple times. |
| */ |
| public class ArgumentAttr extends JCTree.Visitor { |
| |
| protected static final Context.Key<ArgumentAttr> methodAttrKey = new Context.Key<>(); |
| |
| private final DeferredAttr deferredAttr; |
| private final Attr attr; |
| private final Symtab syms; |
| private final Log log; |
| |
| /** Attribution environment to be used. */ |
| private Env<AttrContext> env; |
| |
| /** Result of method attribution. */ |
| private Type result; |
| |
| /** Cache for argument types; behavior is influences by the currrently selected cache policy. */ |
| Map<UniquePos, ArgumentType<?>> argumentTypeCache = new LinkedHashMap<>(); |
| |
| public static ArgumentAttr instance(Context context) { |
| ArgumentAttr instance = context.get(methodAttrKey); |
| if (instance == null) |
| instance = new ArgumentAttr(context); |
| return instance; |
| } |
| |
| protected ArgumentAttr(Context context) { |
| context.put(methodAttrKey, this); |
| deferredAttr = DeferredAttr.instance(context); |
| attr = Attr.instance(context); |
| syms = Symtab.instance(context); |
| log = Log.instance(context); |
| } |
| |
| /** |
| * Set the results of method attribution. |
| */ |
| void setResult(JCExpression tree, Type type) { |
| result = type; |
| if (env.info.isSpeculative) { |
| //if we are in a speculative branch we can save the type in the tree itself |
| //as there's no risk of polluting the original tree. |
| tree.type = result; |
| } |
| } |
| |
| /** |
| * Checks a type in the speculative tree against a given result; the type can be either a plain |
| * type or an argument type,in which case a more complex check is required. |
| */ |
| Type checkSpeculative(JCExpression expr, ResultInfo resultInfo) { |
| return checkSpeculative(expr, expr.type, resultInfo); |
| } |
| |
| /** |
| * Checks a type in the speculative tree against a given result; the type can be either a plain |
| * type or an argument type,in which case a more complex check is required. |
| */ |
| Type checkSpeculative(DiagnosticPosition pos, Type t, ResultInfo resultInfo) { |
| if (t.hasTag(DEFERRED)) { |
| return ((DeferredType)t).check(resultInfo); |
| } else { |
| return resultInfo.check(pos, t); |
| } |
| } |
| |
| /** |
| * Returns a local caching context in which argument types can safely be cached without |
| * the risk of polluting enclosing contexts. This is useful when attempting speculative |
| * attribution of potentially erroneous expressions, which could end up polluting the cache. |
| */ |
| LocalCacheContext withLocalCacheContext() { |
| return new LocalCacheContext(); |
| } |
| |
| /** |
| * Local cache context; this class keeps track of the previous cache and reverts to it |
| * when the {@link LocalCacheContext#leave()} method is called. |
| */ |
| class LocalCacheContext { |
| Map<UniquePos, ArgumentType<?>> prevCache; |
| |
| public LocalCacheContext() { |
| this.prevCache = argumentTypeCache; |
| argumentTypeCache = new HashMap<>(); |
| } |
| |
| public void leave() { |
| argumentTypeCache = prevCache; |
| } |
| } |
| |
| /** |
| * Main entry point for attributing an argument with given tree and attribution environment. |
| */ |
| Type attribArg(JCTree tree, Env<AttrContext> env) { |
| Env<AttrContext> prevEnv = this.env; |
| try { |
| this.env = env; |
| tree.accept(this); |
| return result; |
| } finally { |
| this.env = prevEnv; |
| } |
| } |
| |
| @Override |
| public void visitTree(JCTree that) { |
| //delegates to Attr |
| that.accept(attr); |
| result = attr.result; |
| } |
| |
| /** |
| * Process a method argument; this method takes care of performing a speculative pass over the |
| * argument tree and calling a well-defined entry point to build the argument type associated |
| * with such tree. |
| */ |
| @SuppressWarnings("unchecked") |
| <T extends JCExpression, Z extends ArgumentType<T>> void processArg(T that, Function<T, Z> argumentTypeFactory) { |
| UniquePos pos = new UniquePos(that); |
| processArg(that, () -> { |
| T speculativeTree = (T)deferredAttr.attribSpeculative(that, env, attr.new MethodAttrInfo() { |
| @Override |
| protected void attr(JCTree tree, Env<AttrContext> env) { |
| //avoid speculative attribution loops |
| if (!new UniquePos(tree).equals(pos)) { |
| super.attr(tree, env); |
| } else { |
| visitTree(tree); |
| } |
| } |
| }); |
| return argumentTypeFactory.apply(speculativeTree); |
| }); |
| } |
| |
| /** |
| * Process a method argument; this method allows the caller to specify a custom speculative attribution |
| * logic (this is used e.g. for lambdas). |
| */ |
| @SuppressWarnings("unchecked") |
| <T extends JCExpression, Z extends ArgumentType<T>> void processArg(T that, Supplier<Z> argumentTypeFactory) { |
| UniquePos pos = new UniquePos(that); |
| Z cached = (Z)argumentTypeCache.get(pos); |
| if (cached != null) { |
| //dup existing speculative type |
| setResult(that, cached.dup(that, env)); |
| } else { |
| Z res = argumentTypeFactory.get(); |
| argumentTypeCache.put(pos, res); |
| setResult(that, res); |
| } |
| } |
| |
| @Override |
| public void visitParens(JCParens that) { |
| processArg(that, speculativeTree -> new ParensType(that, env, speculativeTree)); |
| } |
| |
| @Override |
| public void visitConditional(JCConditional that) { |
| processArg(that, speculativeTree -> new ConditionalType(that, env, speculativeTree)); |
| } |
| |
| @Override |
| public void visitReference(JCMemberReference tree) { |
| //perform arity-based check |
| Env<AttrContext> localEnv = env.dup(tree); |
| JCExpression exprTree = (JCExpression)deferredAttr.attribSpeculative(tree.getQualifierExpression(), localEnv, |
| attr.memberReferenceQualifierResult(tree)); |
| JCMemberReference mref2 = new TreeCopier<Void>(attr.make).copy(tree); |
| mref2.expr = exprTree; |
| Symbol res = |
| attr.rs.getMemberReference(tree, localEnv, mref2, |
| exprTree.type, tree.name); |
| if (!res.kind.isResolutionError()) { |
| tree.sym = res; |
| } |
| if (res.kind.isResolutionTargetError() || |
| res.type != null && res.type.hasTag(FORALL) || |
| (res.flags() & Flags.VARARGS) != 0 || |
| (TreeInfo.isStaticSelector(exprTree, tree.name.table.names) && |
| exprTree.type.isRaw())) { |
| tree.overloadKind = JCMemberReference.OverloadKind.OVERLOADED; |
| } else { |
| tree.overloadKind = JCMemberReference.OverloadKind.UNOVERLOADED; |
| } |
| //return a plain old deferred type for this |
| setResult(tree, deferredAttr.new DeferredType(tree, env)); |
| } |
| |
| @Override |
| public void visitLambda(JCLambda that) { |
| if (that.paramKind == ParameterKind.EXPLICIT) { |
| //if lambda is explicit, we can save info in the corresponding argument type |
| processArg(that, () -> { |
| JCLambda speculativeLambda = |
| deferredAttr.attribSpeculativeLambda(that, env, attr.methodAttrInfo); |
| return new ExplicitLambdaType(that, env, speculativeLambda); |
| }); |
| } else { |
| //otherwise just use a deferred type |
| setResult(that, deferredAttr.new DeferredType(that, env)); |
| } |
| } |
| |
| @Override |
| public void visitApply(JCMethodInvocation that) { |
| if (that.getTypeArguments().isEmpty()) { |
| processArg(that, speculativeTree -> new ResolvedMethodType(that, env, speculativeTree)); |
| } else { |
| //not a poly expression, just call Attr |
| setResult(that, attr.attribTree(that, env, attr.unknownExprInfo)); |
| } |
| } |
| |
| @Override |
| public void visitNewClass(JCNewClass that) { |
| if (TreeInfo.isDiamond(that)) { |
| processArg(that, speculativeTree -> new ResolvedConstructorType(that, env, speculativeTree)); |
| } else { |
| //not a poly expression, just call Attr |
| setResult(that, attr.attribTree(that, env, attr.unknownExprInfo)); |
| } |
| } |
| |
| /** |
| * An argument type is similar to a plain deferred type; the most important difference is that |
| * the completion logic associated with argument types allows speculative attribution to be skipped |
| * during overload resolution - that is, an argument type always has enough information to |
| * perform an overload check without the need of calling back to Attr. This extra information |
| * is typically stored in the form of a speculative tree. |
| */ |
| abstract class ArgumentType<T extends JCExpression> extends DeferredType implements DeferredTypeCompleter { |
| |
| /** The speculative tree carrying type information. */ |
| T speculativeTree; |
| |
| /** Types associated with this argument (one type per possible target result). */ |
| Map<ResultInfo, Type> speculativeTypes; |
| |
| public ArgumentType(JCExpression tree, Env<AttrContext> env, T speculativeTree, Map<ResultInfo, Type> speculativeTypes) { |
| deferredAttr.super(tree, env); |
| this.speculativeTree = speculativeTree; |
| this.speculativeTypes = speculativeTypes; |
| } |
| |
| @Override |
| final DeferredTypeCompleter completer() { |
| return this; |
| } |
| |
| @Override |
| final public Type complete(DeferredType dt, ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) { |
| Assert.check(dt == this); |
| if (deferredAttrContext.mode == AttrMode.SPECULATIVE) { |
| Type t = (resultInfo.pt == Type.recoveryType) ? |
| deferredAttr.basicCompleter.complete(dt, resultInfo, deferredAttrContext) : |
| overloadCheck(resultInfo, deferredAttrContext); |
| speculativeTypes.put(resultInfo, t); |
| return t; |
| } else { |
| if (!env.info.isSpeculative) { |
| argumentTypeCache.remove(new UniquePos(dt.tree)); |
| } |
| return deferredAttr.basicCompleter.complete(dt, resultInfo, deferredAttrContext); |
| } |
| } |
| |
| @Override |
| Type speculativeType(Symbol msym, MethodResolutionPhase phase) { |
| for (Map.Entry<ResultInfo, Type> _entry : speculativeTypes.entrySet()) { |
| DeferredAttrContext deferredAttrContext = _entry.getKey().checkContext.deferredAttrContext(); |
| if (deferredAttrContext.phase == phase && deferredAttrContext.msym == msym) { |
| return _entry.getValue(); |
| } |
| } |
| return Type.noType; |
| } |
| |
| @Override |
| JCTree speculativeTree(DeferredAttrContext deferredAttrContext) { |
| return speculativeTree; |
| } |
| |
| /** |
| * Performs an overload check against a given target result. |
| */ |
| abstract Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext); |
| |
| /** |
| * Creates a copy of this argument type with given tree and environment. |
| */ |
| abstract ArgumentType<T> dup(T tree, Env<AttrContext> env); |
| } |
| |
| /** |
| * Argument type for parenthesized expression. |
| */ |
| class ParensType extends ArgumentType<JCParens> { |
| ParensType(JCExpression tree, Env<AttrContext> env, JCParens speculativeParens) { |
| this(tree, env, speculativeParens, new HashMap<>()); |
| } |
| |
| ParensType(JCExpression tree, Env<AttrContext> env, JCParens speculativeParens, Map<ResultInfo, Type> speculativeTypes) { |
| super(tree, env, speculativeParens, speculativeTypes); |
| } |
| |
| @Override |
| Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) { |
| return checkSpeculative(speculativeTree.expr, resultInfo); |
| } |
| |
| @Override |
| ArgumentType<JCParens> dup(JCParens tree, Env<AttrContext> env) { |
| return new ParensType(tree, env, speculativeTree, speculativeTypes); |
| } |
| } |
| |
| /** |
| * Argument type for conditionals. |
| */ |
| class ConditionalType extends ArgumentType<JCConditional> { |
| ConditionalType(JCExpression tree, Env<AttrContext> env, JCConditional speculativeCond) { |
| this(tree, env, speculativeCond, new HashMap<>()); |
| } |
| |
| ConditionalType(JCExpression tree, Env<AttrContext> env, JCConditional speculativeCond, Map<ResultInfo, Type> speculativeTypes) { |
| super(tree, env, speculativeCond, speculativeTypes); |
| } |
| |
| @Override |
| Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) { |
| ResultInfo localInfo = resultInfo.dup(attr.conditionalContext(resultInfo.checkContext)); |
| if (speculativeTree.isStandalone()) { |
| return localInfo.check(speculativeTree, speculativeTree.type); |
| } else if (resultInfo.pt.hasTag(VOID)) { |
| //this means we are returning a poly conditional from void-compatible lambda expression |
| resultInfo.checkContext.report(tree, attr.diags.fragment("conditional.target.cant.be.void")); |
| return attr.types.createErrorType(resultInfo.pt); |
| } else { |
| //poly |
| checkSpeculative(speculativeTree.truepart, localInfo); |
| checkSpeculative(speculativeTree.falsepart, localInfo); |
| return localInfo.pt; |
| } |
| } |
| |
| @Override |
| ArgumentType<JCConditional> dup(JCConditional tree, Env<AttrContext> env) { |
| return new ConditionalType(tree, env, speculativeTree, speculativeTypes); |
| } |
| } |
| |
| /** |
| * Argument type for explicit lambdas. |
| */ |
| class ExplicitLambdaType extends ArgumentType<JCLambda> { |
| |
| /** List of argument types (lazily populated). */ |
| Optional<List<Type>> argtypes = Optional.empty(); |
| |
| /** List of return expressions (lazily populated). */ |
| Optional<List<JCReturn>> returnExpressions = Optional.empty(); |
| |
| ExplicitLambdaType(JCLambda originalLambda, Env<AttrContext> env, JCLambda speculativeLambda) { |
| this(originalLambda, env, speculativeLambda, new HashMap<>()); |
| } |
| |
| ExplicitLambdaType(JCLambda originalLambda, Env<AttrContext> env, JCLambda speculativeLambda, Map<ResultInfo, Type> speculativeTypes) { |
| super(originalLambda, env, speculativeLambda, speculativeTypes); |
| } |
| |
| /** Compute argument types (if needed). */ |
| List<Type> argtypes() { |
| return argtypes.orElseGet(() -> { |
| List<Type> res = TreeInfo.types(speculativeTree.params); |
| argtypes = Optional.of(res); |
| return res; |
| }); |
| } |
| |
| /** Compute return expressions (if needed). */ |
| List<JCReturn> returnExpressions() { |
| return returnExpressions.orElseGet(() -> { |
| final List<JCReturn> res; |
| if (speculativeTree.getBodyKind() == BodyKind.EXPRESSION) { |
| res = List.of(attr.make.Return((JCExpression)speculativeTree.body)); |
| } else { |
| ListBuffer<JCReturn> returnExpressions = new ListBuffer<>(); |
| new LambdaReturnScanner() { |
| @Override |
| public void visitReturn(JCReturn tree) { |
| returnExpressions.add(tree); |
| } |
| }.scan(speculativeTree.body); |
| res = returnExpressions.toList(); |
| } |
| returnExpressions = Optional.of(res); |
| return res; |
| }); |
| } |
| |
| @Override |
| Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) { |
| try { |
| //compute target-type; this logic could be shared with Attr |
| TargetInfo targetInfo = attr.getTargetInfo(speculativeTree, resultInfo, argtypes()); |
| Type lambdaType = targetInfo.descriptor; |
| Type currentTarget = targetInfo.target; |
| //check compatibility |
| checkLambdaCompatible(lambdaType, resultInfo); |
| return currentTarget; |
| } catch (FunctionDescriptorLookupError ex) { |
| resultInfo.checkContext.report(null, ex.getDiagnostic()); |
| return null; //cannot get here |
| } |
| } |
| |
| /** Check lambda against given target result */ |
| private void checkLambdaCompatible(Type descriptor, ResultInfo resultInfo) { |
| CheckContext checkContext = resultInfo.checkContext; |
| ResultInfo bodyResultInfo = attr.lambdaBodyResult(speculativeTree, descriptor, resultInfo); |
| for (JCReturn ret : returnExpressions()) { |
| Type t = getReturnType(ret); |
| if (speculativeTree.getBodyKind() == BodyKind.EXPRESSION || !t.hasTag(VOID)) { |
| checkSpeculative(ret.expr, t, bodyResultInfo); |
| } |
| } |
| |
| attr.checkLambdaCompatible(speculativeTree, descriptor, checkContext); |
| } |
| |
| /** Get the type associated with given return expression. */ |
| Type getReturnType(JCReturn ret) { |
| if (ret.expr == null) { |
| return syms.voidType; |
| } else { |
| return ret.expr.type; |
| } |
| } |
| |
| @Override |
| ArgumentType<JCLambda> dup(JCLambda tree, Env<AttrContext> env) { |
| return new ExplicitLambdaType(tree, env, speculativeTree, speculativeTypes); |
| } |
| } |
| |
| /** |
| * Argument type for methods/constructors. |
| */ |
| abstract class ResolvedMemberType<E extends JCExpression> extends ArgumentType<E> { |
| |
| public ResolvedMemberType(JCExpression tree, Env<AttrContext> env, E speculativeMethod, Map<ResultInfo, Type> speculativeTypes) { |
| super(tree, env, speculativeMethod, speculativeTypes); |
| } |
| |
| @Override |
| Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) { |
| Type mtype = methodType(); |
| ResultInfo localInfo = resultInfo(resultInfo); |
| if (mtype != null && mtype.hasTag(METHOD) && mtype.isPartial()) { |
| Type t = ((PartiallyInferredMethodType)mtype).check(localInfo); |
| if (!deferredAttrContext.inferenceContext.free(localInfo.pt)) { |
| speculativeTypes.put(localInfo, t); |
| return localInfo.check(tree.pos(), t); |
| } else { |
| return t; |
| } |
| } else { |
| Type t = localInfo.check(tree.pos(), speculativeTree.type); |
| speculativeTypes.put(localInfo, t); |
| return t; |
| } |
| } |
| |
| /** |
| * Get the result info to be used for performing an overload check. |
| */ |
| abstract ResultInfo resultInfo(ResultInfo resultInfo); |
| |
| /** |
| * Get the method type to be used for performing an overload check. |
| */ |
| abstract Type methodType(); |
| } |
| |
| /** |
| * Argument type for methods. |
| */ |
| class ResolvedMethodType extends ResolvedMemberType<JCMethodInvocation> { |
| |
| public ResolvedMethodType(JCExpression tree, Env<AttrContext> env, JCMethodInvocation speculativeTree) { |
| this(tree, env, speculativeTree, new HashMap<>()); |
| } |
| |
| public ResolvedMethodType(JCExpression tree, Env<AttrContext> env, JCMethodInvocation speculativeTree, Map<ResultInfo, Type> speculativeTypes) { |
| super(tree, env, speculativeTree, speculativeTypes); |
| } |
| |
| @Override |
| ResultInfo resultInfo(ResultInfo resultInfo) { |
| return resultInfo; |
| } |
| |
| @Override |
| Type methodType() { |
| return speculativeTree.meth.type; |
| } |
| |
| @Override |
| ArgumentType<JCMethodInvocation> dup(JCMethodInvocation tree, Env<AttrContext> env) { |
| return new ResolvedMethodType(tree, env, speculativeTree, speculativeTypes); |
| } |
| } |
| |
| /** |
| * Argument type for constructors. |
| */ |
| class ResolvedConstructorType extends ResolvedMemberType<JCNewClass> { |
| |
| public ResolvedConstructorType(JCExpression tree, Env<AttrContext> env, JCNewClass speculativeTree) { |
| this(tree, env, speculativeTree, new HashMap<>()); |
| } |
| |
| public ResolvedConstructorType(JCExpression tree, Env<AttrContext> env, JCNewClass speculativeTree, Map<ResultInfo, Type> speculativeTypes) { |
| super(tree, env, speculativeTree, speculativeTypes); |
| } |
| |
| @Override |
| ResultInfo resultInfo(ResultInfo resultInfo) { |
| return resultInfo.dup(attr.diamondContext(speculativeTree, speculativeTree.clazz.type.tsym, resultInfo.checkContext)); |
| } |
| |
| @Override |
| Type methodType() { |
| return (speculativeTree.constructorType != null) ? |
| speculativeTree.constructorType.baseType() : syms.errType; |
| } |
| |
| @Override |
| ArgumentType<JCNewClass> dup(JCNewClass tree, Env<AttrContext> env) { |
| return new ResolvedConstructorType(tree, env, speculativeTree, speculativeTypes); |
| } |
| } |
| |
| /** |
| * An instance of this class represents a unique position in a compilation unit. A unique |
| * position is made up of (i) a unique position in a source file (char offset) and (ii) |
| * a source file info. |
| */ |
| class UniquePos { |
| |
| /** Char offset. */ |
| int pos; |
| |
| /** Source info. */ |
| DiagnosticSource source; |
| |
| UniquePos(JCTree tree) { |
| this.pos = tree.pos; |
| this.source = log.currentSource(); |
| } |
| |
| @Override |
| public int hashCode() { |
| return pos << 16 + source.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (obj instanceof UniquePos) { |
| UniquePos that = (UniquePos)obj; |
| return pos == that.pos && source == that.source; |
| } else { |
| return false; |
| } |
| } |
| |
| @Override |
| public String toString() { |
| return source.getFile().getName() + " @ " + source.getLineNumber(pos); |
| } |
| } |
| } |
