org.eclipse.xtext.xbase.typesystem.internal

Class AbstractPendingLinkingCandidate<Expression extends XExpression>

java.lang.Object

org.eclipse.xtext.xbase.typesystem.internal.AbstractLinkingCandidate<Expression>

org.eclipse.xtext.xbase.typesystem.internal.AbstractPendingLinkingCandidate<Expression>

All Implemented Interfaces:

IApplicableCandidate, ILinkingCandidate

Direct Known Subclasses:

ConstructorLinkingCandidate, FeatureLinkingCandidate, TypeLiteralLinkingCandidate

public abstract class AbstractPendingLinkingCandidate<Expression extends XExpression>
extends AbstractLinkingCandidate<Expression>

Abstract base for linking candidates that attempt to resolve features which are not yet bound. This implements the overload resolution and disambiguation. That is, it can be compared to another candidate and return the better match.

Author:

Sebastian Zarnekow - Initial contribution and API

Nested Class Summary

Nested classes/interfaces inherited from class org.eclipse.xtext.xbase.typesystem.internal.AbstractLinkingCandidate

AbstractLinkingCandidate.ArgumentTypeComputationState, AbstractLinkingCandidate.ObservableTypeExpectation

Field Summary

Fields

Modifier and Type	Field and Description
protected IIdentifiableElementDescription	description The backing feature descriptions.

Fields inherited from class org.eclipse.xtext.xbase.typesystem.internal.AbstractLinkingCandidate

arguments, typeArguments

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractPendingLinkingCandidate(Expression expression, IIdentifiableElementDescription description, ITypeExpectation expectation, ExpressionTypeComputationState state)
protected	AbstractPendingLinkingCandidate(Expression expression, IIdentifiableElementDescription description, ITypeExpectation expectation, ExpressionTypeComputationState state, PendingLinkingCandidateResolver<Expression> pendingLinkingCandidateResolver)

Method Summary

Methods

Modifier and Type	Method and Description
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByArgumentTypes(AbstractPendingLinkingCandidate<?> right)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByArgumentTypes(AbstractPendingLinkingCandidate<?> right, boolean recompute)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByArgumentTypes(AbstractPendingLinkingCandidate<?> other, int leftBoxing, int rightBoxing, int leftDemand, int rightDemand) Compare this linking candidate with the given other candidate at argumentIndex Returns CandidateCompareResult#THIS if this candidate is better, CandidateCompareResult#OTHER if the right candidate was better, CandidateCompareResult#AMBIGUOUS if both candidates are valid but ambiguous or CandidateCompareResult#EQUALLY_INVALID if both candidates are ambiguous but erroneous.
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByArgumentTypesFlags(AbstractPendingLinkingCandidate<?> other, int leftIdx, int rightIdx, int leftConformance, int rightConformance) Compare this linking candidate with the given other candidate at leftIdx and rightIdx respectively.
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByArity(int leftArityMismatch, int rightArityMismatch)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByArityWith(AbstractPendingLinkingCandidate<?> right)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByBoxing(int leftBoxing, int rightBoxing)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByBucket(AbstractPendingLinkingCandidate<?> right)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByName(AbstractPendingLinkingCandidate<?> right)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByTypeArguments(AbstractPendingLinkingCandidate<?> right)
protected int	compareDeclaredTypes(LightweightTypeReference left, LightweightTypeReference right, boolean leftResolved, boolean rightResolved)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareExpectedArgumentTypes(AbstractPendingLinkingCandidate<?> right)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareTo(AbstractPendingLinkingCandidate<?> right) Returns CandidateCompareResult#THIS if this candidate is better, CandidateCompareResult#OTHER if the right candidate was better, CandidateCompareResult#AMBIGUOUS if both candidates are valid but ambiguous or CandidateCompareResult#EQUALLY_INVALID if both candidates are ambiguous but erroneous.
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareTo(AbstractPendingLinkingCandidate<?> right, boolean invalid) Returns CandidateCompareResult#THIS if this candidate is better, CandidateCompareResult#OTHER if the right candidate was better, CandidateCompareResult#AMBIGUOUS if both candidates are valid but ambiguous or CandidateCompareResult#EQUALLY_INVALID if both candidates are ambiguous but erroneous.
protected abstract ILinkingCandidate	createAmbiguousLinkingCandidate(AbstractPendingLinkingCandidate<?> second) Produce a candidate that carries the information about ambiguous candidates.
protected ILinkingCandidate	createSuspiciousLinkingCandidate(AbstractPendingLinkingCandidate<?> chosenCandidate) Produce a candidate that carries the information about suspicious overload resolution where a member on 'this' wins over a member on 'it'.
protected String	getArgumentTypesAsString() Returns the resolved string representation of the argument types.
int	getArityMismatch() Returns the mismatch of actually given arguments and declared parameters.
protected int	getArityMismatch(JvmExecutable executable, List<XExpression> arguments)
protected int	getConformanceFlags(int idx, boolean recompute)
protected org.eclipse.emf.ecore.EReference	getDefaultValidationFeature()
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	getExpectedTypeCompareResultOther(AbstractPendingLinkingCandidate<?> other) Returns the compare result for the declared parameter types if the given other candidate had won.
JvmIdentifiableElement	getFeature() The currently considered feature (if any).
protected String	getFeatureParameterTypesAsString() Returns the unresolved string representation of the parameter types of the feature.
protected String	getFeatureParameterTypesAsString(JvmExecutable executable)
protected abstract String	getFeatureTypeName() Returns the name of the feature type, e.g. a feature of type JvmOperation may return method, a XVariableDeclaration may identify itself as local variable.
protected String	getFeatureTypeParametersAsString(boolean showBounds) Returns the unresolved string representation of the unresolved type parameters of the feature.
protected org.eclipse.emf.ecore.EReference	getInvalidArgumentsValidationFeature()
ILinkingCandidate	getPreferredCandidate(ILinkingCandidate other) Returns the best candidate considering the this and the given other candidate.
protected Severity	getSeverity(String issueCode) Returns the current severity for the given issue code.
protected String	getSimpleFeatureName()
protected List<XExpression>	getSyntacticArguments()
protected int	getTypeArgumentConformanceFailures(IAcceptor<? super AbstractDiagnostic> acceptor)
protected String	getTypeArgumentsAsString(List<? extends LightweightTypeReference> typeArguments) Returns the resolved string representation of the type arguments.
int	getTypeArityMismatch()
protected String	getTypeParameterAsString(JvmTypeParameter typeParameter) Returns the unresolved string representation of the given type parameter.
protected Map<JvmTypeParameter,LightweightMergedBoundTypeArgument>	getTypeParameterMapping() Returns the mapping of type parameters to their bound arguments.
protected Severity	getUnhandledExceptionSeverity(JvmExecutable executable) Obtain the currently applicable severity for uncaught exceptions.
protected boolean	isDefiniteEarlyExit(XExpression expression)
protected boolean	isExtension()
protected boolean	isLambdaExpression(int argumentIdx)
protected boolean	isPossibleFunctionType(int idx) Returns false if the argument expression is a lambda and the expected type of the argument is not a function type or Object.
protected boolean	isVarArgs()
protected boolean	isVisible()
protected void	resolveLinkingProxy(org.eclipse.emf.ecore.EReference structuralFeature, int featureId)
String	toString()
boolean	validate(IAcceptor<? super AbstractDiagnostic> result) Validates this linking candidate and adds respective diagnostics to the given queue.
protected boolean	validateArity(IAcceptor<? super AbstractDiagnostic> result)
protected boolean	validateTypeArgumentConformance(IAcceptor<? super AbstractDiagnostic> result)
protected boolean	validateTypeArity(IAcceptor<? super AbstractDiagnostic> result)
protected boolean	validateUnhandledExceptions(IAcceptor<? super AbstractDiagnostic> result)
protected boolean	validateUnhandledExceptions(JvmExecutable executable, IAcceptor<? super AbstractDiagnostic> result)
protected boolean	validateVisibility(IAcceptor<? super AbstractDiagnostic> result)

Methods inherited from class org.eclipse.xtext.xbase.typesystem.internal.AbstractLinkingCandidate

accept, applyToComputationState, computeArgumentType, computeArgumentTypes, computeFixedArityArgumentType, computeVarArgumentType, createArgumentTypeSubstitutor, createLinkingTypeComputationState, createVarArgTypeComputationState, deferredBindTypeArgument, discardRefinementTypeIfReassigned, getActualType, getActualType, getArguments, getDeclaratorParameterMapping, getDeclaredType, getDeclaredTypeParameters, getExpectedType, getExpression, getPlainSyntacticTypeArguments, getState, getSubstitutedExpectedType, getSyntacticTypeArguments, getTypeArguments, hasReceiver, initializeArgumentTypeComputation, initializeConstraintMapping, initializeMapping, initializeTypeParameterMapping, initializeTypeParameterMapping, isBoundTypeArgumentSkipped, isRawTypeContext, isTypeLiteral, mustDiscardRefinement, preApply, resolveAgainstActualType, resolveArgumentType

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.xtext.xbase.typesystem.computation.ILinkingCandidate

applyToModel

Field Detail

description

protected final IIdentifiableElementDescription description

The backing feature descriptions. It carries the information about the potentially resolved feature, e.g. the implicit receiver, whether it's an extension and more.

Constructor Detail

AbstractPendingLinkingCandidate

protected AbstractPendingLinkingCandidate(Expression expression,
                               IIdentifiableElementDescription description,
                               ITypeExpectation expectation,
                               ExpressionTypeComputationState state)

AbstractPendingLinkingCandidate

protected AbstractPendingLinkingCandidate(Expression expression,
                               IIdentifiableElementDescription description,
                               ITypeExpectation expectation,
                               ExpressionTypeComputationState state,
                               PendingLinkingCandidateResolver<Expression> pendingLinkingCandidateResolver)

Method Detail

getTypeParameterMapping

protected Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> getTypeParameterMapping()

Returns the mapping of type parameters to their bound arguments.

Specified by:

getTypeParameterMapping in class AbstractLinkingCandidate<Expression extends XExpression>

See Also:

AbstractLinkingCandidate.initializeTypeParameterMapping()

getFeatureTypeName

protected abstract String getFeatureTypeName()

Returns the name of the feature type, e.g. a feature of type JvmOperation may return method, a XVariableDeclaration may identify itself as local variable.

getArgumentTypesAsString

protected String getArgumentTypesAsString()

Returns the resolved string representation of the argument types. The simple names of the types are used. The string representation includes the parenthesis.

getFeatureParameterTypesAsString

protected String getFeatureParameterTypesAsString()

Returns the unresolved string representation of the parameter types of the feature. The simple names of the types are used. The string representation includes the parenthesis.

getFeatureParameterTypesAsString

protected String getFeatureParameterTypesAsString(JvmExecutable executable)

getFeatureTypeParametersAsString

protected String getFeatureTypeParametersAsString(boolean showBounds)

Returns the unresolved string representation of the unresolved type parameters of the feature. The simple names of the type bounds are used. The string representation includes the angle brackets.

getTypeParameterAsString

protected String getTypeParameterAsString(JvmTypeParameter typeParameter)

Returns the unresolved string representation of the given type parameter. The simple names of the type bounds are used. The string representation includes the bounds, except for the upper bound Object.

getTypeArgumentsAsString

protected String getTypeArgumentsAsString(List<? extends LightweightTypeReference> typeArguments)

Returns the resolved string representation of the type arguments. The simple names of the types are used. The string representation includes the angle brackets.

validate

public boolean validate(IAcceptor<? super AbstractDiagnostic> result)

Validates this linking candidate and adds respective diagnostics to the given queue. This checks the following criteria:

1. visibility,
2. arity,
3. type arity,
4. type arguments,
5. unhandled excptions,

Returns:

true if further validation should be performed.

validateVisibility

protected boolean validateVisibility(IAcceptor<? super AbstractDiagnostic> result)

getSimpleFeatureName

protected String getSimpleFeatureName()

getDefaultValidationFeature

protected org.eclipse.emf.ecore.EReference getDefaultValidationFeature()

getInvalidArgumentsValidationFeature

protected org.eclipse.emf.ecore.EReference getInvalidArgumentsValidationFeature()

validateArity

protected boolean validateArity(IAcceptor<? super AbstractDiagnostic> result)

validateTypeArity

protected boolean validateTypeArity(IAcceptor<? super AbstractDiagnostic> result)

validateTypeArgumentConformance

protected boolean validateTypeArgumentConformance(IAcceptor<? super AbstractDiagnostic> result)

validateUnhandledExceptions

protected boolean validateUnhandledExceptions(IAcceptor<? super AbstractDiagnostic> result)

validateUnhandledExceptions

protected boolean validateUnhandledExceptions(JvmExecutable executable,
                                  IAcceptor<? super AbstractDiagnostic> result)

getUnhandledExceptionSeverity

protected Severity getUnhandledExceptionSeverity(JvmExecutable executable)

Obtain the currently applicable severity for uncaught exceptions. Sneaky throw techniques cannot be applied to delegating constructor calls. Therefore it's possible to raise the severity for them by checking the linked executable.

Parameters:

executable - the executable that declares the exception.

getSeverity

protected Severity getSeverity(String issueCode)

Returns the current severity for the given issue code.

isDefiniteEarlyExit

protected boolean isDefiniteEarlyExit(XExpression expression)

getSyntacticArguments

protected List<XExpression> getSyntacticArguments()

getPreferredCandidate

public ILinkingCandidate getPreferredCandidate(ILinkingCandidate other)

Returns the best candidate considering the this and the given other candidate. The result is not necessarily this or the other, but may also be a third instance, e.g. in order to disambiguate certain error conditions.

createAmbiguousLinkingCandidate

protected abstract ILinkingCandidate createAmbiguousLinkingCandidate(AbstractPendingLinkingCandidate<?> second)

Produce a candidate that carries the information about ambiguous candidates.

createSuspiciousLinkingCandidate

protected ILinkingCandidate createSuspiciousLinkingCandidate(AbstractPendingLinkingCandidate<?> chosenCandidate)

Produce a candidate that carries the information about suspicious overload resolution where a member on 'this' wins over a member on 'it'.

Parameters:

chosenCandidate - the candidate that was picked.

compareTo

protected final org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareTo(AbstractPendingLinkingCandidate<?> right)

Returns CandidateCompareResult#THIS if this candidate is better, CandidateCompareResult#OTHER if the right candidate was better, CandidateCompareResult#AMBIGUOUS if both candidates are valid but ambiguous or CandidateCompareResult#EQUALLY_INVALID if both candidates are ambiguous but erroneous.

See Also:

compareTo(AbstractPendingLinkingCandidate, boolean)

compareTo

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareTo(AbstractPendingLinkingCandidate<?> right,
                                                                           boolean invalid)

Returns CandidateCompareResult#THIS if this candidate is better, CandidateCompareResult#OTHER if the right candidate was better, CandidateCompareResult#AMBIGUOUS if both candidates are valid but ambiguous or CandidateCompareResult#EQUALLY_INVALID if both candidates are ambiguous but erroneous. The invalid flag indicates if we already know that both candidates are equally invalid.

compareByName

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByName(AbstractPendingLinkingCandidate<?> right)

compareByBucket

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByBucket(AbstractPendingLinkingCandidate<?> right)

isVisible

protected boolean isVisible()

isVarArgs

protected boolean isVarArgs()

isExtension

protected boolean isExtension()

compareByArgumentTypes

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByArgumentTypes(AbstractPendingLinkingCandidate<?> right)

compareByTypeArguments

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByTypeArguments(AbstractPendingLinkingCandidate<?> right)

getTypeArgumentConformanceFailures

protected int getTypeArgumentConformanceFailures(IAcceptor<? super AbstractDiagnostic> acceptor)

compareByArgumentTypes

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByArgumentTypes(AbstractPendingLinkingCandidate<?> right,
                                                                                        boolean recompute)

compareByArgumentTypesFlags

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByArgumentTypesFlags(AbstractPendingLinkingCandidate<?> other,
                                                                                             int leftIdx,
                                                                                             int rightIdx,
                                                                                             int leftConformance,
                                                                                             int rightConformance)

Compare this linking candidate with the given other candidate at leftIdx and rightIdx respectively. Returns CandidateCompareResult#THIS if this candidate is better, CandidateCompareResult#OTHER if the right candidate was better, CandidateCompareResult#AMBIGUOUS if both candidates are valid but ambiguous or CandidateCompareResult#EQUALLY_INVALID if both candidates are ambiguous but erroneous.

Parameters:

other - the other candidate

leftIdx - the semantic argument index on this candidate

rightIdx - the semantic argument index on the other candidate

leftConformance - the computed conformance in this linking candidate

rightConformance - the computed conformance if the other candidate was chosen

compareByArgumentTypes

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByArgumentTypes(AbstractPendingLinkingCandidate<?> other,
                                                                                        int leftBoxing,
                                                                                        int rightBoxing,
                                                                                        int leftDemand,
                                                                                        int rightDemand)

Compare this linking candidate with the given other candidate at argumentIndex Returns CandidateCompareResult#THIS if this candidate is better, CandidateCompareResult#OTHER if the right candidate was better, CandidateCompareResult#AMBIGUOUS if both candidates are valid but ambiguous or CandidateCompareResult#EQUALLY_INVALID if both candidates are ambiguous but erroneous.

Parameters:

other - the other candidate (the rhs of the comparison)

leftBoxing - the number of required boxing conversions if this candidate was chosen

rightBoxing - the number of required boxing conversions if the other candidate was chosen

leftDemand - the number of required demand conversions if this candidate was chosen

rightDemand - the number of required demand conversions if the other candidate was chosen

compareByBoxing

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByBoxing(int leftBoxing,
                                                                                 int rightBoxing)

isPossibleFunctionType

protected boolean isPossibleFunctionType(int idx)

Returns false if the argument expression is a lambda and the expected type of the argument is not a function type or Object. Returns true in all other cases. This serves as a shortcut to rule out decision path's where a method is overloaded and one of the overloads accepts a function type but the other doesn't. In those cases it is not necessary to compute the type of the lamdba expression twice. An example for this pattern is IterableExtensions.filter(Iterable, Class) vs IterableExtensions.filter(Iterable, org.eclipse.xtext.xbase.lib.Functions.Function1).

getConformanceFlags

protected int getConformanceFlags(int idx,
                      boolean recompute)

isLambdaExpression

protected boolean isLambdaExpression(int argumentIdx)

compareExpectedArgumentTypes

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareExpectedArgumentTypes(AbstractPendingLinkingCandidate<?> right)

compareDeclaredTypes

protected int compareDeclaredTypes(LightweightTypeReference left,
                       LightweightTypeReference right,
                       boolean leftResolved,
                       boolean rightResolved)

getExpectedTypeCompareResultOther

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult getExpectedTypeCompareResultOther(AbstractPendingLinkingCandidate<?> other)

Returns the compare result for the declared parameter types if the given other candidate had won.

Parameters:

other - the winner of the comparison.

compareByArityWith

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByArityWith(AbstractPendingLinkingCandidate<?> right)

compareByArity

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByArity(int leftArityMismatch,
                                                                                int rightArityMismatch)

getArityMismatch

public int getArityMismatch()

Returns the mismatch of actually given arguments and declared parameters. Receivers and staticness of the feature is taken into account, too. The mismatch may either be negative or positive.

getTypeArityMismatch

public int getTypeArityMismatch()

resolveLinkingProxy

protected void resolveLinkingProxy(org.eclipse.emf.ecore.EReference structuralFeature,
                       int featureId)

getArityMismatch

protected int getArityMismatch(JvmExecutable executable,
                   List<XExpression> arguments)

getFeature

public JvmIdentifiableElement getFeature()

Description copied from interface: ILinkingCandidate

The currently considered feature (if any). Otherwise null.

Specified by:

getFeature in interface ILinkingCandidate

Specified by:

getFeature in class AbstractLinkingCandidate<Expression extends XExpression>

toString

public String toString()

Overrides:

toString in class Object