org.eclipse.xtext.xbase.typesystem.internal

Class FeatureLinkingCandidate

java.lang.Object

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

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

org.eclipse.xtext.xbase.typesystem.internal.FeatureLinkingCandidate

All Implemented Interfaces:

IFeatureNames, IApplicableCandidate, IFeatureLinkingCandidate, ILinkingCandidate

public class FeatureLinkingCandidate
extends AbstractPendingLinkingCandidate<XAbstractFeatureCall>
implements IFeatureLinkingCandidate, IFeatureNames

A linking candidate that represents a feature call and allows to resolve overloaded members.

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 inherited from class org.eclipse.xtext.xbase.typesystem.internal.AbstractPendingLinkingCandidate

description

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

arguments, typeArguments

Fields inherited from interface org.eclipse.xtext.xbase.scoping.batch.IFeatureNames

IT, SELF, SUPER, THIS

Constructor Summary

Constructors

Constructor and Description
FeatureLinkingCandidate(XAbstractFeatureCall featureCall, IIdentifiableElementDescription description, ITypeExpectation expectation, ExpressionTypeComputationState state)

Method Summary

Methods

Modifier and Type	Method and Description
protected void	applyImplicitReceiver()
void	applyToModel(IResolvedTypes resolvedTypes) Injects the resolved feature into the model with the same semantics as the implicit resolve of EMF.
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<?> right, 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	compareByArgumentTypes(FeatureLinkingCandidate right, int leftBoxing, int rightBoxing)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByArgumentTypesAndStaticFlag(FeatureLinkingCandidate right, int leftBoxing, int rightBoxing)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByArgumentTypesFlags(AbstractPendingLinkingCandidate<?> right, 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	compareByArityWith(AbstractPendingLinkingCandidate<?> right)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	compareByAssignmentName(AbstractPendingLinkingCandidate<?> right)
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	compareByNameAndStaticFlag(AbstractPendingLinkingCandidate<?> right)
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 void	computeVarArgumentType(IFeatureCallArgumentSlot slot, TypeParameterSubstitutor<?> substitutor)
protected ILinkingCandidate	createAmbiguousLinkingCandidate(AbstractPendingLinkingCandidate<?> second) Produce a candidate that carries the information about ambiguous candidates.
protected List<XExpression>	createArgumentList(XExpression head, List<XExpression> tail)
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 List<XExpression>	getArguments() Returns the actual arguments of the expression.
protected int	getConformanceFlags(int idx, boolean recompute)
protected Map<JvmTypeParameter,LightweightMergedBoundTypeArgument>	getDeclaratorParameterMapping()
protected LightweightTypeReference	getDeclaredType(JvmIdentifiableElement feature)
protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult	getExpectedTypeCompareResultOther(AbstractPendingLinkingCandidate<?> right) Returns the compare result for the declared parameter types if the given other candidate had won.
XAbstractFeatureCall	getFeatureCall() Returns the feature call that is linked.
protected 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 XExpression	getFirstArgument() Returns the first argument if this is an extension.
protected LightweightTypeReference	getFirstArgumentType()
protected XExpression	getImplicitFirstArgument()
protected LightweightTypeReference	getImplicitFirstArgumentType()
protected XExpression	getImplicitReceiver()
protected LightweightTypeReference	getImplicitReceiverType()
protected List<JvmTypeReference>	getPlainSyntacticTypeArguments()
protected XExpression	getReceiver()
protected int	getReceiverConformanceFlags()
protected LightweightTypeReference	getReceiverType()
protected LightweightTypeReference	getSubstitutedExpectedType(int idx) Returns the substituted expected type for the argument at argumentIndex.
protected List<XExpression>	getSyntacticArguments()
protected XExpression	getSyntacticReceiver()
protected XExpression	getSyntacticReceiverIfPossibleArgument() Returns the syntactic receiver if it is an expression.
protected LightweightTypeReference	getSyntacticReceiverType()
protected Severity	getUnhandledExceptionSeverity(JvmExecutable executable) Obtain the currently applicable severity for uncaught exceptions.
protected boolean	hasReceiver() Returns true if the argument at index 0 will be considered as the receiver.
protected void	initializeMapping(JvmTypeParameter typeParameter, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> result)
protected boolean	isAmbiguousExtensionProvider(AbstractPendingLinkingCandidate<?> right)
protected boolean	isAssignmentOrMemberFeatureCall()
protected boolean	isCompoundOperator()
protected boolean	isExplicitOperationCall()
boolean	isExtension() Returns true if the the linked feature is contributed by an extension.
protected boolean	isFirstArgument(int argumentIndex)
protected boolean	isGetClass(JvmIdentifiableElement feature)
protected boolean	isGetClassOnTypeLiteral() Returns true if the method Object.getClass() is bound and the receiver is a type literal.
protected boolean	isImplicitlyStatic(XAssignment assignment)
protected boolean	isInvalidStaticSyntax() Returns true if a static member is accessed with an instance receiver, e.g.
protected boolean	isLambdaExpression(int argumentIdx)
protected boolean	isOperationCallSyntax()
protected boolean	isRawTypeContext()
protected boolean	isReassignFirstArgument(XAbstractFeatureCall featureCall)
protected boolean	isSimpleAssignment(XAssignment assignment)
boolean	isStatic() Returns true if the the linked feature is static.
protected boolean	isStaticAccessSyntax()
protected boolean	isStaticWithDeclaringType()
protected boolean	isStaticWithDeclaringType(XAssignment assignment)
protected boolean	isSyntacticReceiverPossibleArgument() Returns true if the linked receiver could be a possible argument of this feature.
boolean	isTypeLiteral() Returns true if the the feature call is linked as a type literal.
protected boolean	isTypeLiteral(XExpression expression)
protected boolean	isValidAssignmentName(IIdentifiableElementDescription description)
protected void	preApply()
protected void	resolveAgainstActualType(LightweightTypeReference declaredType, LightweightTypeReference actualType, AbstractTypeComputationState state)
protected void	resolveArgumentType(XExpression argument, LightweightTypeReference declaredType, ITypeComputationState argumentState)
protected void	resolveKnownArgumentType(XExpression argument, LightweightTypeReference knownType, LightweightTypeReference declaredType, ITypeComputationState argumentState)
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)

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

compareByArity, compareByBoxing, compareByTypeArguments, compareDeclaredTypes, compareExpectedArgumentTypes, compareTo, getArgumentTypesAsString, getArityMismatch, getArityMismatch, getDefaultValidationFeature, getFeature, getFeatureParameterTypesAsString, getFeatureParameterTypesAsString, getFeatureTypeParametersAsString, getInvalidArgumentsValidationFeature, getPreferredCandidate, getSeverity, getSimpleFeatureName, getTypeArgumentConformanceFailures, getTypeArgumentsAsString, getTypeArityMismatch, getTypeParameterAsString, getTypeParameterMapping, isDefiniteEarlyExit, isPossibleFunctionType, isVarArgs, isVisible, resolveLinkingProxy, toString, validateTypeArgumentConformance, validateTypeArity, validateUnhandledExceptions, validateUnhandledExceptions, validateVisibility

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

accept, applyToComputationState, computeArgumentType, computeArgumentTypes, computeFixedArityArgumentType, createArgumentTypeSubstitutor, createLinkingTypeComputationState, createVarArgTypeComputationState, deferredBindTypeArgument, discardRefinementTypeIfReassigned, getActualType, getActualType, getDeclaredTypeParameters, getExpectedType, getExpression, getState, getSyntacticTypeArguments, getTypeArguments, initializeArgumentTypeComputation, initializeConstraintMapping, initializeTypeParameterMapping, initializeTypeParameterMapping, isBoundTypeArgumentSkipped, mustDiscardRefinement

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

applyToComputationState, getExpression, getFeature, getPreferredCandidate, getTypeArguments

Constructor Detail

FeatureLinkingCandidate

public FeatureLinkingCandidate(XAbstractFeatureCall featureCall,
                       IIdentifiableElementDescription description,
                       ITypeExpectation expectation,
                       ExpressionTypeComputationState state)

Method Detail

createAmbiguousLinkingCandidate

protected ILinkingCandidate createAmbiguousLinkingCandidate(AbstractPendingLinkingCandidate<?> second)

Description copied from class: AbstractPendingLinkingCandidate

Produce a candidate that carries the information about ambiguous candidates.

Specified by:

createAmbiguousLinkingCandidate in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

createSuspiciousLinkingCandidate

protected ILinkingCandidate createSuspiciousLinkingCandidate(AbstractPendingLinkingCandidate<?> chosenCandidate)

Description copied from class: AbstractPendingLinkingCandidate

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

Overrides:

createSuspiciousLinkingCandidate in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

Parameters:

chosenCandidate - the candidate that was picked.

isRawTypeContext

protected boolean isRawTypeContext()

Overrides:

isRawTypeContext in class AbstractLinkingCandidate<XAbstractFeatureCall>

initializeMapping

protected void initializeMapping(JvmTypeParameter typeParameter,
                     Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> result)

Overrides:

initializeMapping in class AbstractLinkingCandidate<XAbstractFeatureCall>

getArguments

protected List<XExpression> getArguments()

Returns the actual arguments of the expression. These do not include the receiver.

Specified by:

getArguments in class AbstractLinkingCandidate<XAbstractFeatureCall>

validate

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

Validates this linking candidate and adds respective diagnostics to the given queue. In addition to the checks that are inherited from AbstractPendingLinkingCandidate.validate(IAcceptor), the candidate is validated according these criteria:

1. syntax for static feature calls,
2. static context for static members,
3. field accessed as a method, e.g. with parentheses,
4. usage of this or super in an invalid context,
5. direct invocation of an abstract method,
6. attempt to enclose a non-final local variable in a lambda expression,
7. reference to a private feature with a subclass instance,
8. errorprone invocation of getClass().

Specified by:

validate in interface IApplicableCandidate

Overrides:

validate in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

Returns:

true if further validation should be performed.

validateArity

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

Overrides:

validateArity in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

isReassignFirstArgument

protected boolean isReassignFirstArgument(XAbstractFeatureCall featureCall)

isInvalidStaticSyntax

protected boolean isInvalidStaticSyntax()

Returns true if a static member is accessed with an instance receiver, e.g. myLocalVariable.STATIC_METHOD(..) or myLocalVariable.STATIC_FIELD = null.

isStaticWithDeclaringType

protected boolean isStaticWithDeclaringType()

isStaticWithDeclaringType

protected boolean isStaticWithDeclaringType(XAssignment assignment)

isImplicitlyStatic

protected boolean isImplicitlyStatic(XAssignment assignment)

isTypeLiteral

protected boolean isTypeLiteral(XExpression expression)

isOperationCallSyntax

protected boolean isOperationCallSyntax()

getFeatureTypeName

protected String getFeatureTypeName()

Description copied from class: AbstractPendingLinkingCandidate

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.

Specified by:

getFeatureTypeName in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

isStaticAccessSyntax

protected boolean isStaticAccessSyntax()

isAssignmentOrMemberFeatureCall

protected boolean isAssignmentOrMemberFeatureCall()

isSimpleAssignment

protected boolean isSimpleAssignment(XAssignment assignment)

createArgumentList

protected List<XExpression> createArgumentList(XExpression head,
                                   List<XExpression> tail)

getSyntacticArguments

protected List<XExpression> getSyntacticArguments()

Overrides:

getSyntacticArguments in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

isExtension

public boolean isExtension()

Description copied from interface: IFeatureLinkingCandidate

Returns true if the the linked feature is contributed by an extension.

Specified by:

isExtension in interface IFeatureLinkingCandidate

Overrides:

isExtension in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

Returns:

whether the feature is extension.

hasReceiver

protected boolean hasReceiver()

Description copied from class: AbstractLinkingCandidate

Returns true if the argument at index 0 will be considered as the receiver.

Overrides:

hasReceiver in class AbstractLinkingCandidate<XAbstractFeatureCall>

isStatic

public boolean isStatic()

Description copied from interface: IFeatureLinkingCandidate

Returns true if the the linked feature is static.

Specified by:

isStatic in interface IFeatureLinkingCandidate

Returns:

whether the feature is static.

isSyntacticReceiverPossibleArgument

protected boolean isSyntacticReceiverPossibleArgument()

Returns true if the linked receiver could be a possible argument of this feature. Basically it's false if this feature is an error feature, a local variable or a if the receiver is a type literal that's treated as a static qualifier rather than a literal expression.

isTypeLiteral

public boolean isTypeLiteral()

Description copied from interface: IFeatureLinkingCandidate

Returns true if the the feature call is linked as a type literal.

Specified by:

isTypeLiteral in interface IFeatureLinkingCandidate

Overrides:

isTypeLiteral in class AbstractLinkingCandidate<XAbstractFeatureCall>

Returns:

whether the feature call is a type literal rather than a real feature call.

getExpectedTypeCompareResultOther

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

Description copied from class: AbstractPendingLinkingCandidate

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

Overrides:

getExpectedTypeCompareResultOther in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

Parameters:

right - the winner of the comparison.

getConformanceFlags

protected int getConformanceFlags(int idx,
                      boolean recompute)

Overrides:

getConformanceFlags in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

isLambdaExpression

protected boolean isLambdaExpression(int argumentIdx)

Overrides:

isLambdaExpression in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

getSubstitutedExpectedType

protected LightweightTypeReference getSubstitutedExpectedType(int idx)

Description copied from class: AbstractLinkingCandidate

Returns the substituted expected type for the argument at argumentIndex. If the expected type is an unbound type parameter, a reference to the type parameter itself is returned.

Overrides:

getSubstitutedExpectedType in class AbstractLinkingCandidate<XAbstractFeatureCall>

isExplicitOperationCall

protected boolean isExplicitOperationCall()

compareByName

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

Overrides:

compareByName in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

compareByArgumentTypes

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

Overrides:

compareByArgumentTypes in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

compareByArgumentTypes

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

Overrides:

compareByArgumentTypes in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

compareByNameAndStaticFlag

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

isCompoundOperator

protected boolean isCompoundOperator()

compareByBucket

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

Overrides:

compareByBucket in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

isAmbiguousExtensionProvider

protected boolean isAmbiguousExtensionProvider(AbstractPendingLinkingCandidate<?> right)

compareTo

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

Description copied from class: AbstractPendingLinkingCandidate

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.

Overrides:

compareTo in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

compareByAssignmentName

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

isValidAssignmentName

protected boolean isValidAssignmentName(IIdentifiableElementDescription description)

compareByArityWith

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

Overrides:

compareByArityWith in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

compareByArgumentTypesFlags

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

Description copied from class: AbstractPendingLinkingCandidate

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.

Overrides:

compareByArgumentTypesFlags in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

Parameters:

right - 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

isFirstArgument

protected boolean isFirstArgument(int argumentIndex)

compareByArgumentTypes

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

Description copied from class: AbstractPendingLinkingCandidate

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.

Overrides:

compareByArgumentTypes in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

Parameters:

right - 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

compareByArgumentTypes

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByArgumentTypes(FeatureLinkingCandidate right,
                                                                                        int leftBoxing,
                                                                                        int rightBoxing)

compareByArgumentTypesAndStaticFlag

protected org.eclipse.xtext.xbase.typesystem.internal.CandidateCompareResult compareByArgumentTypesAndStaticFlag(FeatureLinkingCandidate right,
                                                                                                     int leftBoxing,
                                                                                                     int rightBoxing)

preApply

protected void preApply()

Overrides:

preApply in class AbstractLinkingCandidate<XAbstractFeatureCall>

applyImplicitReceiver

protected void applyImplicitReceiver()

resolveAgainstActualType

protected void resolveAgainstActualType(LightweightTypeReference declaredType,
                            LightweightTypeReference actualType,
                            AbstractTypeComputationState state)

Overrides:

resolveAgainstActualType in class AbstractLinkingCandidate<XAbstractFeatureCall>

getFeatureCall

public XAbstractFeatureCall getFeatureCall()

Description copied from interface: IFeatureLinkingCandidate

Returns the feature call that is linked.

Specified by:

getFeatureCall in interface IFeatureLinkingCandidate

Returns:

the feature call.

getPlainSyntacticTypeArguments

protected List<JvmTypeReference> getPlainSyntacticTypeArguments()

Specified by:

getPlainSyntacticTypeArguments in class AbstractLinkingCandidate<XAbstractFeatureCall>

resolveArgumentType

protected void resolveArgumentType(XExpression argument,
                       LightweightTypeReference declaredType,
                       ITypeComputationState argumentState)

Overrides:

resolveArgumentType in class AbstractLinkingCandidate<XAbstractFeatureCall>

Parameters:

argument - the expression that should be processed.

declaredType - the declared (expected) type for the given expression.

argumentState - the to-be-used state to compute the actual type of the argument. It is already configured with the expectation.

resolveKnownArgumentType

protected void resolveKnownArgumentType(XExpression argument,
                            LightweightTypeReference knownType,
                            LightweightTypeReference declaredType,
                            ITypeComputationState argumentState)

computeVarArgumentType

protected void computeVarArgumentType(IFeatureCallArgumentSlot slot,
                          TypeParameterSubstitutor<?> substitutor)

Overrides:

computeVarArgumentType in class AbstractLinkingCandidate<XAbstractFeatureCall>

getDeclaratorParameterMapping

protected Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> getDeclaratorParameterMapping()

Overrides:

getDeclaratorParameterMapping in class AbstractLinkingCandidate<XAbstractFeatureCall>

getReceiver

protected XExpression getReceiver()

getReceiverType

protected LightweightTypeReference getReceiverType()

getReceiverConformanceFlags

protected int getReceiverConformanceFlags()

getFirstArgument

protected XExpression getFirstArgument()

Returns the first argument if this is an extension. This may be the implicit first argument or the syntactic receiver of the feature call.

getFirstArgumentType

protected LightweightTypeReference getFirstArgumentType()

getImplicitReceiver

protected XExpression getImplicitReceiver()

getImplicitReceiverType

protected LightweightTypeReference getImplicitReceiverType()

getSyntacticReceiver

protected XExpression getSyntacticReceiver()

getSyntacticReceiverIfPossibleArgument

protected XExpression getSyntacticReceiverIfPossibleArgument()

Returns the syntactic receiver if it is an expression. Type literals are not considered to be expressions thus null is returned as the syntactic receiver of the expression valueOf(..) in java.lang.String.valueOf(..).

getSyntacticReceiverType

protected LightweightTypeReference getSyntacticReceiverType()

getImplicitFirstArgument

protected XExpression getImplicitFirstArgument()

getImplicitFirstArgumentType

protected LightweightTypeReference getImplicitFirstArgumentType()

getDeclaredType

protected LightweightTypeReference getDeclaredType(JvmIdentifiableElement feature)

Overrides:

getDeclaredType in class AbstractLinkingCandidate<XAbstractFeatureCall>

isGetClassOnTypeLiteral

protected boolean isGetClassOnTypeLiteral()

Returns true if the method Object.getClass() is bound and the receiver is a type literal. This may indicate a bug.

isGetClass

protected boolean isGetClass(JvmIdentifiableElement feature)

applyToModel

public void applyToModel(IResolvedTypes resolvedTypes)

Description copied from interface: ILinkingCandidate

Injects the resolved feature into the model with the same semantics as the implicit resolve of EMF. This implies that the linked feature call may still point to a proxy afterwards.

Specified by:

applyToModel in interface IApplicableCandidate

Specified by:

applyToModel in interface ILinkingCandidate

getUnhandledExceptionSeverity

protected Severity getUnhandledExceptionSeverity(JvmExecutable executable)

Description copied from class: AbstractPendingLinkingCandidate

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.

Overrides:

getUnhandledExceptionSeverity in class AbstractPendingLinkingCandidate<XAbstractFeatureCall>

Parameters:

executable - the executable that declares the exception.