/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public override void Fill(List<INamable> retVal, BaseFilter filter)
{
if (filter.AcceptableChoice(Value))
{
retVal.Add(Value);
}
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
// Iterator expression
IteratorExpression.SemanticAnalysis(instance, AllMatches.INSTANCE);
StaticUsage.AddUsages(IteratorExpression.StaticUsage, Usage.ModeEnum.Read);
}
return retVal;
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public virtual bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = !SemanticAnalysisDone;
if (retVal)
{
StaticUsage = new Usages();
SemanticAnalysisDone = true;
}
return retVal;
}
/// <summary>
/// Adds a reference which satisfies the provided expectation in the result set
/// </summary>
/// <param name="namable"></param>
/// <param name="expectation"></param>
/// <param name="asType">Indicates that we had to move from instance to type to perform the deferencing</param>
/// <param name="resultSet"></param>
private int addReference(INamable namable, BaseFilter expectation, bool asType, ReturnValue resultSet)
{
int retVal = 0;
if (namable != null)
{
if (expectation.AcceptableChoice(namable))
{
if (asType)
{
if (!(namable is IValue) && !(namable is Type))
{
resultSet.Add(namable);
retVal += 1;
}
else if (namable is State)
{
// TODO : Refactor model to avoid this
resultSet.Add(namable);
retVal += 1;
}
}
else
{
resultSet.Add(namable);
retVal += 1;
}
}
}
return retVal;
}
/// <summary>
/// Provides the possible references for this designator (only available during semantic analysis)
/// </summary>
/// <param name="instance">the instance on which this element should be found.</param>
/// <param name="expectation">the expectation on the element found</param>
/// <param name="lastElement">Indicates that this element is the last one in a dereference chain</param>
/// <returns></returns>
public ReturnValue GetReferences(INamable instance, BaseFilter expectation, bool lastElement)
{
ReturnValue retVal = new ReturnValue(this);
if (instance == null)
{
// Special handling for THIS or ENCLOSING
if (Image == ThisKeyword || Image == EnclosingKeyword)
{
INamable currentElem = Root;
while (currentElem != null)
{
Type type = currentElem as Type;
if (type != null)
{
StateMachine stateMachine = type as StateMachine;
while (stateMachine != null)
{
type = stateMachine;
stateMachine = stateMachine.EnclosingStateMachine;
}
// Enclosing does not references state machines.
if (!(Image == EnclosingKeyword && type is StateMachine))
{
retVal.Add(type);
return retVal;
}
}
currentElem = enclosing(currentElem);
}
return retVal;
}
// No enclosing instance. Try to first name of a . separated list of names
// . First in the enclosing expression
InterpreterTreeNode current = this;
while (current != null)
{
ISubDeclarator subDeclarator = current as ISubDeclarator;
if (FillBySubdeclarator(subDeclarator, expectation, false, retVal) > 0)
{
// If this is the last element in the dereference chain, stop at first match
if (lastElement)
{
return retVal;
}
current = null;
}
else
{
current = current.Enclosing;
}
}
// . In the predefined elements
addReference(EfsSystem.Instance.GetPredefinedItem(Image), expectation, false, retVal);
if (lastElement && !retVal.IsEmpty)
{
return retVal;
}
// . In the enclosing items, except the enclosing dictionary since dictionaries are handled in a later step
INamable currentNamable = Root;
while (currentNamable != null)
{
ISubDeclarator subDeclarator = currentNamable as ISubDeclarator;
if (subDeclarator != null && !(subDeclarator is Dictionary))
{
if (FillBySubdeclarator(subDeclarator, expectation, false, retVal) > 0 && lastElement)
{
return retVal;
}
}
currentNamable = EnclosingSubDeclarator(currentNamable);
}
// . In the dictionaries declared in the system
foreach (Dictionary dictionary in EfsSystem.Instance.Dictionaries)
{
if (FillBySubdeclarator(dictionary, expectation, false, retVal) > 0 && lastElement)
{
return retVal;
}
NameSpace defaultNameSpace = dictionary.FindNameSpace("Default");
if (defaultNameSpace != null)
{
if (FillBySubdeclarator(defaultNameSpace, expectation, false, retVal) > 0 && lastElement)
{
return retVal;
}
}
}
}
else
{
// The instance is provided, hence, this is not the first designator in the . separated list of designators
bool asType = false;
if (instance is ITypedElement && !(instance is State))
{
// If the instance is a typed element, dereference it to its corresponding type
ITypedElement element = instance as ITypedElement;
if (element.Type != EfsSystem.Instance.NoType)
{
instance = element.Type;
asType = true;
}
}
// Find the element in all enclosing sub declarators of the instance
while (instance != null)
{
ISubDeclarator subDeclarator = instance as ISubDeclarator;
if (FillBySubdeclarator(subDeclarator, expectation, asType, retVal) > 0)
{
instance = null;
}
else
{
if (instance is Dictionary)
{
instance = EnclosingSubDeclarator(instance);
}
else
{
instance = null;
}
}
}
}
return retVal;
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
// Structure
if (Structure != null)
{
Structure.SemanticAnalysis(instance, IsStructure.INSTANCE);
StaticUsage.AddUsages(Structure.StaticUsage, Usage.ModeEnum.Type);
// Structure field Association
if (Associations != null)
{
Structure structureType = Structure.Ref as Structure;
foreach (KeyValuePair<Designator, Expression> pair in Associations)
{
if (structureType != null)
{
pair.Key.Ref = structureType.FindStructureElement(pair.Key.Image);
StaticUsage.AddUsage(pair.Key.Ref, Root, Usage.ModeEnum.Parameter);
}
pair.Value.SemanticAnalysis(instance, IsRightSide.INSTANCE);
StaticUsage.AddUsages(pair.Value.StaticUsage, Usage.ModeEnum.Read);
}
}
}
}
return retVal;
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
// Accumulator
AccumulatorVariable.Type = GetExpressionType();
if (DefinedAccumulator != null)
{
DefinedAccumulator.SemanticAnalysis(instance, AllMatches.INSTANCE);
Accumulator.SemanticAnalysis(instance, AllMatches.INSTANCE);
StaticUsage.AddUsages(Accumulator.StaticUsage, Usage.ModeEnum.Read);
}
else
{
AddError("Accumulator expression not provided", RuleChecksEnum.SemanticAnalysisError);
}
}
return retVal;
}
/// <summary>
/// Provides the possible references types for this expression (used in semantic analysis)
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <param name="last">indicates that this is the last element in a dereference chain</param>
/// <returns></returns>
public override ReturnValue GetReferenceTypes(INamable instance, BaseFilter expectation, bool last)
{
ReturnValue retVal = ReturnValue.Empty;
if (Term != null)
{
retVal = Term.GetReferenceTypes(instance, expectation, last);
}
else
{
if (Expression != null)
{
retVal = Expression.GetReferenceTypes(instance, expectation, true);
}
}
return retVal;
}
/// <summary>
/// Performs the semantic analysis of the term
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <param name="lastElement">Indicates that this element is the last one in a dereference chain</param>
/// <returns>True if semantic analysis should be continued</returns>
public void SemanticAnalysis(INamable instance, BaseFilter expectation, bool lastElement)
{
if (Designator != null)
{
Designator.SemanticAnalysis(instance, expectation, lastElement);
StaticUsage = Designator.StaticUsage;
}
else if (LiteralValue != null)
{
LiteralValue.SemanticAnalysis(instance, expectation);
StaticUsage = LiteralValue.StaticUsage;
}
}
/// <summary>
/// Provides the possible references types for this expression (used in semantic analysis)
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <param name="last">indicates that this is the last element in a dereference chain</param>
/// <returns></returns>
public ReturnValue GetReferenceTypes(INamable instance, BaseFilter expectation, bool last)
{
ReturnValue retVal = null;
if (Designator != null)
{
retVal = new ReturnValue();
foreach (ReturnValueElement element in Designator.GetReferences(instance, expectation, last).Values)
{
if (element.Value is Type)
{
const bool asType = true;
retVal.Add(element.Value, null, asType);
}
}
}
else if (LiteralValue != null)
{
retVal = LiteralValue.GetReferenceTypes(instance, expectation, true);
}
return retVal;
}
/// <summary>
/// Provides the possible references for this term (only available during semantic analysis)
/// </summary>
/// <param name="instance">the instance on which this element should be found.</param>
/// <param name="expectation">the expectation on the element found</param>
/// <param name="last">indicates that this is the last element in a dereference chain</param>
/// <returns></returns>
public ReturnValue GetReferences(INamable instance, BaseFilter expectation, bool last)
{
ReturnValue retVal = null;
if (Designator != null)
{
retVal = Designator.GetReferences(instance, expectation, last);
}
else if (LiteralValue != null)
{
retVal = LiteralValue.GetReferences(instance, expectation, last);
}
return retVal;
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public void Fill(List<INamable> retVal, BaseFilter filter)
{
if (Designator != null)
{
Designator.Fill(retVal, filter);
}
else if (LiteralValue != null)
{
LiteralValue.Fill(retVal, filter);
}
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
if (Expression != null)
{
Expression.SemanticAnalysis(instance, AllMatches.INSTANCE);
StaticUsage.AddUsages(Expression.StaticUsage, null);
}
else
{
AddError("Function body not provided");
}
}
return retVal;
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public override void Fill(List<INamable> retVal, BaseFilter filter)
{
if (Parameters != null)
{
foreach (Parameter parameter in Parameters)
{
if (filter.AcceptableChoice(parameter))
{
retVal.Add(parameter);
}
}
}
if (Expression != null)
{
Expression.Fill(retVal, filter);
}
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam>
/// <returns>True if semantic analysis should be continued</returns>
public bool SemanticAnalysis(BaseFilter expectation)
{
return SemanticAnalysis(null, expectation);
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
Ref = null;
ReturnValue tmp = getReferences(instance, expectation, false);
if (tmp.IsUnique)
{
// Unique element has been found. Reference it and perform the semantic analysis
// on all dereferenced expression, now that the context is known for each expression
Ref = tmp.Values[0].Value;
StaticUsage.AddUsage(Ref, Root, null);
References referenceFilter;
ReturnValueElement current = tmp.Values[0];
for (int i = Arguments.Count - 1; i > 0; i--)
{
referenceFilter = new References(current.Value);
current = current.PreviousElement;
Arguments[i].SemanticAnalysis(current.Value, referenceFilter);
StaticUsage.AddUsages(Arguments[i].StaticUsage, null);
StaticUsage.AddUsage(Arguments[i].Ref, Root, null);
}
referenceFilter = new References(current.Value);
Arguments[0].SemanticAnalysis(null, referenceFilter);
StaticUsage.AddUsages(Arguments[0].StaticUsage, null);
StaticUsage.AddUsage(Arguments[0].Ref, Root, null);
}
else if (tmp.IsAmbiguous)
{
// Several possible interpretations for this deref expression, not allowed
AddError("Expression " + ToString() + " may have several interpretations " + tmp.ToString() +
", please disambiguate");
}
else
{
// No possible interpretation for this deref expression, not allowed
AddError("Expression " + ToString() + " has no interpretation");
}
}
return retVal;
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
// Accumulator
if (AccumulatorVariable != null)
{
AccumulatorVariable.Type = GetExpressionType();
}
if (DefinedAccumulator != null)
{
DefinedAccumulator.SemanticAnalysis(instance, AllMatches.INSTANCE);
}
if (Accumulator != null)
{
Accumulator.SemanticAnalysis(instance, AllMatches.INSTANCE);
StaticUsage.AddUsages(Accumulator.StaticUsage, Usage.ModeEnum.Read);
}
}
return retVal;
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public override void Fill(List<INamable> retVal, BaseFilter filter)
{
Expression.Fill(retVal, filter);
InitialValue.Fill(retVal, filter);
Condition.Fill(retVal, filter);
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public override void Fill(List<INamable> retVal, BaseFilter filter)
{
if (Term != null)
{
Term.Fill(retVal, filter);
}
if (Expression != null)
{
Expression.Fill(retVal, filter);
}
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
// InitialValue
if (InitialValue != null)
{
InitialValue.SemanticAnalysis(instance, IsRightSide.INSTANCE);
StaticUsage.AddUsages(InitialValue.StaticUsage, Usage.ModeEnum.Read);
LastIteration.Type = InitialValue.GetExpressionType();
CurrentIteration.Type = InitialValue.GetExpressionType();
StaticUsage.AddUsage(InitialValue.GetExpressionType(), Root, Usage.ModeEnum.Type);
}
else
{
AddError("Initial value not provided");
}
// Expression
if (Expression != null)
{
Expression.SemanticAnalysis(instance, AllMatches.INSTANCE);
StaticUsage.AddUsages(Expression.StaticUsage, Usage.ModeEnum.Read);
}
else
{
Root.AddError("Accumulator expression value not provided");
}
// Condition
if (Condition != null)
{
Condition.SemanticAnalysis(instance, AllMatches.INSTANCE);
StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read);
}
else
{
Root.AddError("Stop condition not provided");
}
}
return retVal;
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
if (Term != null)
{
Term.SemanticAnalysis(instance, expectation, true);
StaticUsage = Term.StaticUsage;
}
else if (Expression != null)
{
Expression.SemanticAnalysis(instance, expectation);
StaticUsage = Expression.StaticUsage;
}
}
return retVal;
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public override void Fill(List<INamable> retVal, BaseFilter filter)
{
base.Fill(retVal, filter);
if (Condition != null)
{
Condition.Fill(retVal, filter);
}
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public override void Fill(List<INamable> retVal, BaseFilter filter)
{
foreach (Expression expression in Associations.Values)
{
expression.Fill(retVal, filter);
}
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
// Condition
if (Condition != null)
{
Condition.SemanticAnalysis(instance, expectation);
StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read);
}
}
return retVal;
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public void Fill(List<INamable> retVal, BaseFilter filter)
{
if (filter.AcceptableChoice(Ref))
{
retVal.Add(Ref);
}
}
/// <summary>
/// Performs the semantic analysis of the expression
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <returns>True if semantic analysis should be continued</returns>
public override bool SemanticAnalysis(INamable instance, BaseFilter expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
// Value
Value = new StringValue(EfsSystem.Instance.StringType, Image);
}
return retVal;
}
/// <summary>
/// Performs the semantic analysis of the term
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <param name="lastElement">Indicates that this element is the last one in a dereference chain</param>
/// <returns>True if semantic analysis should be continued</returns>
public void SemanticAnalysis(INamable instance, BaseFilter expectation, bool lastElement)
{
ReturnValue tmp = GetReferences(instance, expectation, lastElement);
if (Image != ThisKeyword && Image != EnclosingKeyword)
{
tmp.Filter(expectation);
}
if (tmp.IsUnique)
{
Ref = tmp.Values[0].Value;
}
if (StaticUsage == null)
{
StaticUsage = new Usages();
StaticUsage.AddUsage(Ref, Root, null);
}
}
/// <summary>
/// Provides the possible references for this expression (only available during semantic analysis)
/// </summary>
/// <param name="instance">the instance on which this element should be found.</param>
/// <param name="expectation">the expectation on the element found</param>
/// <param name="last">indicates that this is the last element in a dereference chain</param>
/// <returns></returns>
public override ReturnValue getReferences(INamable instance, BaseFilter expectation, bool last)
{
ReturnValue retVal = Arguments[0].getReferences(instance, AllMatches.INSTANCE, false);
if (retVal.IsEmpty)
{
retVal = Arguments[0].getReferenceTypes(instance, AllMatches.INSTANCE, false);
}
// When variables & parameters are found, only consider the first one
// which is the one that is closer in the tree
{
ReturnValue tmp2 = retVal;
retVal = new ReturnValue();
ReturnValueElement variable = null;
foreach (ReturnValueElement elem in tmp2.Values)
{
if (elem.Value is Parameter || elem.Value is IVariable)
{
if (variable == null)
{
variable = elem;
retVal.Values.Add(elem);
}
}
else
{
retVal.Values.Add(elem);
}
}
}
if (!retVal.IsEmpty)
{
for (int i = 1; i < Arguments.Count; i++)
{
ReturnValue tmp2 = retVal;
retVal = new ReturnValue(Arguments[i]);
foreach (ReturnValueElement elem in tmp2.Values)
{
bool removed = false;
ModelElement model = elem.Value as ModelElement;
if (model != null)
{
removed = model.IsRemoved;
}
if (!removed)
{
retVal.Merge(elem,
Arguments[i].getReferences(elem.Value, AllMatches.INSTANCE, i == (Arguments.Count - 1)));
}
}
if (retVal.IsEmpty)
{
AddError("Cannot find " + Arguments[i].ToString() + " in " + Arguments[i - 1].ToString());
}
}
}
else
{
AddError("Cannot evaluate " + Arguments[0].ToString());
}
retVal.filter(expectation);
return retVal;
}
/// <summary>
/// Fills the retVal result set according to the subDeclarator class provided as parameter
/// </summary>
/// <param name="subDeclarator">The subdeclarator used to get the image</param>
/// <param name="expectation">The expectatino of the desired element</param>
/// <param name="asType">Indicates that we had to go from the values to the types to perform dereferencing</param>
/// <param name="values">The return value to update</param>
/// <return>the number of elements added</return>
private int FillBySubdeclarator(ISubDeclarator subDeclarator, BaseFilter expectation, bool asType,
ReturnValue values)
{
int retVal = 0;
if (subDeclarator != null)
{
// Go to the beginning of the update chain
ISubDeclarator currentDeclarator = subDeclarator;
ModelElement modelElement = subDeclarator as ModelElement;
while (modelElement != null)
{
if (modelElement.Updates != null)
{
currentDeclarator = modelElement.Updates as ISubDeclarator;
}
modelElement = modelElement.Updates;
}
while (currentDeclarator != null)
{
// Adds the elements of the current declarator
List<INamable> tmp = new List<INamable>();
currentDeclarator.Find(Image, tmp);
foreach (INamable namable in tmp)
{
retVal += addReference(namable, expectation, asType, values);
}
// Follow the update chain
modelElement = currentDeclarator as ModelElement;
if (modelElement != null && modelElement.UpdatedBy.Count == 1)
{
currentDeclarator = modelElement.UpdatedBy[0] as ISubDeclarator;
}
else
{
currentDeclarator = null;
}
}
}
values.ApplyUpdates();
return retVal;
}
/// <summary>
/// Provides the possible references types for this expression (used in semantic analysis)
/// </summary>
/// <param name="instance">the reference instance on which this element should analysed</param>
/// <param name="expectation">Indicates the kind of element we are looking for</param>
/// <param name="last">indicates that this is the last element in a dereference chain</param>
/// <returns></returns>
public virtual ReturnValue GetReferenceTypes(INamable instance, BaseFilter expectation, bool last)
{
ReturnValue retVal = new ReturnValue(this);
SemanticAnalysis(instance, AllMatches.INSTANCE);
const bool asType = true;
retVal.Add(GetExpressionType(), null, asType);
return retVal;
}