@NotNull public GroovyResolveResult[] multiResolve( boolean incomplete) { // incomplete means we do not take arguments into consideration final ResolveResult[] results = TypeInferenceHelper.getCurrentContext().multiResolve(this, incomplete, POLY_RESOLVER); return results.length == 0 ? GroovyResolveResult.EMPTY_ARRAY : (GroovyResolveResult[]) results; }
@Override public PsiType getTypeGroovy() { PsiType type = TypeInferenceHelper.getCurrentContext() .getExpressionType( this, new Function<GrFieldImpl, PsiType>() { @Override public PsiType fun(GrFieldImpl field) { if (getDeclaredType() == null && getInitializerGroovy() == null) { final PsiType type = GrVariableEnhancer.getEnhancedType(field); if (type != null) { return type; } } return null; } }); if (type != null) { return type; } return super.getTypeGroovy(); }
public GroovyResolveResult advancedResolve() { ResolveResult[] results = TypeInferenceHelper.getCurrentContext().multiResolve(this, false, POLY_RESOLVER); return results.length == 1 ? (GroovyResolveResult) results[0] : GroovyResolveResult.EMPTY_RESULT; }
@Nullable private static PsiType getInferredTypes( GrReferenceExpressionImpl refExpr, @Nullable PsiElement resolved) { final GrExpression qualifier = refExpr.getQualifier(); if (qualifier == null && !(resolved instanceof PsiClass)) { return TypeInferenceHelper.getCurrentContext().getVariableType(refExpr); } else if (qualifier != null) { // map access PsiType qType = qualifier.getType(); if (qType instanceof PsiClassType && !(qType instanceof GrMapType)) { PsiClassType.ClassResolveResult qResult = ((PsiClassType) qType).resolveGenerics(); PsiClass clazz = qResult.getElement(); if (clazz != null) { PsiClass mapClass = JavaPsiFacade.getInstance(refExpr.getProject()) .findClass(CommonClassNames.JAVA_UTIL_MAP, refExpr.getResolveScope()); if (mapClass != null && mapClass.getTypeParameters().length == 2) { PsiSubstitutor substitutor = TypeConversionUtil.getClassSubstitutor(mapClass, clazz, qResult.getSubstitutor()); if (substitutor != null) { return TypeConversionUtil.erasure( substitutor.substitute(mapClass.getTypeParameters()[1])); } } } } } return null; }
public static TypeConstraint[] calculateTypeConstraints(@NotNull final GrExpression expression) { return TypeInferenceHelper.getCurrentContext() .getCachedValue( expression, new Computable<TypeConstraint[]>() { @Override public TypeConstraint[] compute() { MyCalculator calculator = new MyCalculator(expression); final PsiElement parent = expression.getParent(); if (parent instanceof GroovyPsiElement) { ((GroovyPsiElement) parent).accept(calculator); } else { parent.accept(new GroovyPsiElementVisitor(calculator)); } final TypeConstraint[] result = calculator.getResult(); List<TypeConstraint> custom = new ArrayList<TypeConstraint>(); for (GroovyExpectedTypesContributor contributor : GroovyExpectedTypesContributor.EP_NAME.getExtensions()) { custom.addAll(contributor.calculateTypeConstraints(expression)); } if (!custom.isEmpty()) { custom.addAll(0, Arrays.asList(result)); return custom.toArray(new TypeConstraint[custom.size()]); } return result; } }); }
@Override public PsiType getInferredReturnType() { if (isConstructor()) { return null; } if (!ApplicationManager.getApplication().isUnitTestMode()) { // todo uncomment when EAP is on // LOG.assertTrue(!ApplicationManager.getApplication().isDispatchThread()); //this is a // potentially long action } return TypeInferenceHelper.getCurrentContext().getExpressionType(this, ourTypesCalculator); }
@Override @Nullable public PsiType fun(final GrReferenceExpressionImpl refExpr) { final Pair key = Pair.create(TypeInferenceHelper.getCurrentContext(), refExpr); return RecursionManager.doPreventingRecursion( key, true, new Computable<PsiType>() { @Override public PsiType compute() { return doFun(refExpr); } }); }
private Pair<Boolean, GroovyResolveResult[]> resolveByShape( boolean allVariants, @Nullable GrExpression upToArgument) { if (allVariants) { return doResolveByShape(allVariants, upToArgument); } LOG.assertTrue(upToArgument == null); return TypeInferenceHelper.getCurrentContext() .getCachedValue( this, new NullableComputable<Pair<Boolean, GroovyResolveResult[]>>() { @Override public Pair<Boolean, GroovyResolveResult[]> compute() { return doResolveByShape(false, null); } }); }
@NotNull private GroovyResolveResult[] doPolyResolveWithCaching( final boolean incompleteCode, final boolean genericsMatter) { final InferenceContext context = TypeInferenceHelper.getCurrentContext(); final Trinity<?, ?, ?> key = Trinity.create(this, context, Pair.create(incompleteCode, genericsMatter)); final GroovyResolveResult[] value = RecursionManager.doPreventingRecursion( key, true, new Computable<GroovyResolveResult[]>() { @Override public GroovyResolveResult[] compute() { return doPolyResolve(incompleteCode, genericsMatter); } }); return value == null ? GroovyResolveResult.EMPTY_ARRAY : value; }
@NotNull private Pair<Boolean, GroovyResolveResult[]> resolveByShape( final boolean allVariants, @Nullable final GrExpression upToArgument) { LOG.assertTrue(allVariants || upToArgument == null); final Trinity key = Trinity.create( TypeInferenceHelper.getCurrentContext(), this, Pair.create(allVariants, upToArgument)); final Pair<Boolean, GroovyResolveResult[]> result = RecursionManager.doPreventingRecursion( key, true, new Computable<Pair<Boolean, GroovyResolveResult[]>>() { @Override public Pair<Boolean, GroovyResolveResult[]> compute() { return doResolveByShape(allVariants, upToArgument); } }); return result == null ? Pair.create(false, GroovyResolveResult.EMPTY_ARRAY) : result; }
@Nullable private static PsiType getInferredTypes( @NotNull GrReferenceExpression refExpr, @Nullable PsiElement resolved) { final GrExpression qualifier = refExpr.getQualifier(); if (!(resolved instanceof PsiClass) && !(resolved instanceof PsiPackage)) { if (qualifier == null) { return TypeInferenceHelper.getCurrentContext().getVariableType(refExpr); } else { // map access PsiType qType = qualifier.getType(); if (qType instanceof PsiClassType && !(qType instanceof GrMapType)) { final PsiType mapValueType = getTypeFromMapAccess(refExpr); if (mapValueType != null) { return mapValueType; } } } } return null; }
@Override public GroovyResolveResult[] resolveByShape() { final InferenceContext context = TypeInferenceHelper.getCurrentContext(); return context.getCachedValue( this, new Computable<GroovyResolveResult[]>() { @Override public GroovyResolveResult[] compute() { Pair<GrReferenceExpressionImpl, InferenceContext> key = Pair.create(GrReferenceExpressionImpl.this, context); GroovyResolveResult[] value = RecursionManager.doPreventingRecursion( key, true, new Computable<GroovyResolveResult[]>() { @Override public GroovyResolveResult[] compute() { return doPolyResolve(false, false); } }); return value == null ? GroovyResolveResult.EMPTY_ARRAY : value; } }); }
public PsiType getType() { return TypeInferenceHelper.getCurrentContext().getExpressionType(this, TYPES_CALCULATOR); }
@NotNull @Override public GroovyResolveResult[] multiResolve(boolean incompleteCode) { return TypeInferenceHelper.getCurrentContext().multiResolve(this, incompleteCode, OUR_RESOLVER); }