private static bool ResolveCallFunction(IPrecursorExpression node, IFeatureInstance selectedPrecursor, IFunctionType callType, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList)
{
selectedParameterList = null;
selectedResultList = null;
resolvedArgumentList = null;
IList <IArgument> ArgumentList = node.ArgumentList;
ICompiledFeature OperatorFeature = selectedPrecursor.Feature;
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
foreach (IQueryOverloadType Overload in callType.OverloadList)
{
ParameterTableList.Add(Overload.ParameterTable);
}
if (!Argument.ArgumentsConformToParameters(ParameterTableList, mergedArgumentList, argumentStyle, errorList, node, out int SelectedIndex))
{
return(false);
}
IFunctionFeature AsFunctionFeature = OperatorFeature as IFunctionFeature;
Debug.Assert(AsFunctionFeature != null);
Debug.Assert(AsFunctionFeature.OverloadList.Count == callType.OverloadList.Count);
resolvedExpression.SelectedOverload = AsFunctionFeature.OverloadList[SelectedIndex];
resolvedExpression.SelectedOverloadType = callType.OverloadList[SelectedIndex];
resolvedExpression.ResolvedResult = new ResultType(resolvedExpression.SelectedOverloadType.ResultTypeList);
resolvedExpression.ResolvedException = new ResultException(resolvedExpression.SelectedOverloadType.ExceptionIdentifierList);
selectedParameterList = resolvedExpression.SelectedOverloadType.ParameterTable;
selectedResultList = resolvedExpression.SelectedOverloadType.ResultTable;
resolvedArgumentList = mergedArgumentList;
return(true);
}
private static bool ResolveCallClass(IPrecursorExpression node, IFeatureInstance selectedPrecursor, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList)
{
selectedParameterList = null;
selectedResultList = null;
resolvedArgumentList = null;
IList <IArgument> ArgumentList = node.ArgumentList;
if (ArgumentList.Count > 0)
{
errorList.AddError(new ErrorInvalidExpression(node));
return(false);
}
else
{
ICompiledFeature OperatorFeature = selectedPrecursor.Feature;
ITypeName OperatorTypeName = OperatorFeature.ResolvedEffectiveTypeName.Item;
ICompiledType OperatorType = OperatorFeature.ResolvedEffectiveType.Item;
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
resolvedExpression.ResolvedResult = new ResultType(OperatorTypeName, OperatorType, string.Empty);
resolvedExpression.ResolvedException = new ResultException();
selectedParameterList = new SealableList <IParameter>();
selectedResultList = new SealableList <IParameter>();
resolvedArgumentList = new List <IExpressionType>();
}
return(true);
}
/// <summary>
/// Initializes the feature precursor hierarchy.
/// </summary>
/// <param name="context">The initialization context.</param>
public override void InitHierarchy(ICSharpContext context)
{
if (Instance.OriginalPrecursor.IsAssigned)
{
IPrecursorInstance Item = Instance.OriginalPrecursor.Item;
ICompiledFeature PrecursorFeature = Item.Precursor.Feature;
OriginalPrecursor = context.GetFeature(PrecursorFeature) as ICSharpProcedureFeature;
Debug.Assert(OriginalPrecursor != null);
IList <ICSharpOverload> PrecursorOverloadList = OriginalPrecursor.OverloadList;
foreach (ICSharpCommandOverload Overload in OverloadList)
{
ICommandOverloadType ResolvedAssociatedType = Overload.Source.ResolvedAssociatedType.Item;
ICSharpCommandOverload ParentPrecursorOverload = null;
foreach (ICSharpCommandOverload PrecursorOverload in PrecursorOverloadList)
{
ICommandOverloadType PrecursorResolvedAssociatedType = PrecursorOverload.Source.ResolvedAssociatedType.Item;
if (ObjectType.CommandOverloadConformToBase(ResolvedAssociatedType, PrecursorResolvedAssociatedType, ErrorList.Ignored, ErrorList.NoLocation))
{
Debug.Assert(ParentPrecursorOverload == null);
ParentPrecursorOverload = PrecursorOverload;
}
}
Debug.Assert(ParentPrecursorOverload != null);
Overload.SetPrecursor(ParentPrecursorOverload);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpEntityExpression"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly expression from which the C# expression is created.</param>
protected CSharpEntityExpression(ICSharpContext context, IEntityExpression source)
: base(context, source)
{
if (Source.ResolvedFinalFeature.IsAssigned)
{
ICompiledFeature ResolvedFeature = Source.ResolvedFinalFeature.Item;
if (ResolvedFeature is IScopeAttributeFeature AsScopeAttributeFeature)
{
ICSharpClass Owner = context.GetClass(source.EmbeddingClass);
Feature = CSharpScopeAttributeFeature.Create(context, Owner, AsScopeAttributeFeature);
}
else
{
Feature = context.GetFeature(Source.ResolvedFinalFeature.Item);
}
}
if (Source.ResolvedFinalDiscrete.IsAssigned)
{
ICSharpClass Class = context.GetClass(Source.ResolvedFinalDiscrete.Item.EmbeddingClass);
foreach (ICSharpDiscrete Item in Class.DiscreteList)
{
if (Item.Source == Source.ResolvedFinalDiscrete.Item)
{
Debug.Assert(Discrete == null);
Discrete = Item;
}
}
}
Debug.Assert((Feature != null && Discrete == null) || (Feature == null && Discrete != null));
Query = CSharpQualifiedName.Create(context, (IQualifiedName)Source.Query, Feature, Discrete, false);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IPrecursorExpression node, object data)
{
ILanguageConstant ExpressionConstant = NeutralLanguageConstant.NotConstant;
Debug.Assert(node.ConstantSourceList.Count > 0);
bool IsConstant = true;
foreach (IExpression ConstantSource in node.ConstantSourceList)
{
IsConstant &= ConstantSource.ExpressionConstant.Item != NeutralLanguageConstant.NotConstant;
}
if (IsConstant)
{
ExpressionConstant = new ObjectLanguageConstant();
Debug.Assert(node.ResolvedPrecursor.IsAssigned);
ICompiledFeature FinalFeature = node.ResolvedPrecursor.Item.Feature;
if (FinalFeature is IConstantFeature AsConstantFeature)
{
Debug.Assert(node.ConstantSourceList.Count == 1);
Debug.Assert(node.ConstantSourceList[0].ExpressionConstant.IsAssigned);
ExpressionConstant = node.ConstantSourceList[0].ExpressionConstant.Item;
}
else
{
ExpressionConstant = Expression.GetDefaultConstant(node, node.ResolvedResult.Item);
}
}
node.ExpressionConstant.Item = ExpressionConstant;
}
private void CheckIfFeatureListed(ISealableDictionary <ICompiledFeature, IList <InstanceNameInfo> > byFeatureTable, AncestorFeatureInfo featureInfo, IFeatureName featureName, IFeatureInstance featureInstance)
{
bool FeatureAlreadyListed = false;
foreach (KeyValuePair <ICompiledFeature, IList <InstanceNameInfo> > ImportedEntry in byFeatureTable)
{
ICompiledFeature ImportedKey = ImportedEntry.Key;
IList <InstanceNameInfo> NameList = ImportedEntry.Value;
// Feature already listed
if (featureInstance.Feature == ImportedKey)
{
UpdateNameList(featureInfo, featureName, featureInstance, NameList);
FeatureAlreadyListed = true;
break;
}
}
if (!FeatureAlreadyListed)
{
IList <InstanceNameInfo> InitList = new List <InstanceNameInfo>();
InstanceNameInfo NewInfo = new InstanceNameInfo(featureInfo, featureInstance, featureName);
InitList.Add(NewInfo);
byFeatureTable.Add(featureInstance.Feature, InitList);
}
}
private static bool IsPathGlobalItemReady(ICompiledFeature itemFeature, IIdentifier nextItem, IErrorList errorList, ref bool isInterrupted, out ICompiledType itemType)
{
bool IsReady = false;
itemType = null;
Debug.Assert(nextItem != null);
Debug.Assert(nextItem.ValidText.IsAssigned);
string NextItemText = nextItem.ValidText.Item;
bool IsHandled = false;
switch (itemFeature)
{
case IAttributeFeature AsAttributeFeature:
IsReady = AsAttributeFeature.ResolvedEntityType.IsAssigned;
itemType = IsReady ? AsAttributeFeature.ResolvedEntityType.Item : null;
IsHandled = true;
break;
case IConstantFeature AsConstantFeature:
IsReady = AsConstantFeature.ResolvedEntityType.IsAssigned;
itemType = IsReady ? AsConstantFeature.ResolvedEntityType.Item : null;
IsHandled = true;
break;
// Creation and procedure features don't return anything.
case ICreationFeature AsCreationFeature:
case IProcedureFeature AsProcedureFeature:
errorList.AddError(new ErrorUnknownIdentifier(nextItem, NextItemText));
isInterrupted = true;
return(false);
case IFunctionFeature AsFunctionFeature:
IsReady = AsFunctionFeature.MostCommonResult.IsAssigned;
itemType = IsReady ? AsFunctionFeature.MostCommonResult.Item.ValueType : null;
IsHandled = true;
break;
case IPropertyFeature AsPropertyFeature:
IsReady = AsPropertyFeature.ResolvedEntityType.IsAssigned;
itemType = IsReady ? AsPropertyFeature.ResolvedEntityType.Item : null;
IsHandled = true;
break;
case IIndexerFeature AsIndexerFeature:
IsReady = AsIndexerFeature.ResolvedEntityType.IsAssigned;
itemType = IsReady ? AsIndexerFeature.ResolvedEntityType.Item : null;
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
return(IsReady);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IAgentExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item4;
ICompiledFeature ResolvedFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item5;
node.ResolvedException.Item = ResolvedException;
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(IPrecursorIndexAssignmentInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IExpression SourceExpression = (IExpression)node.Source;
IResultType SourceResult = SourceExpression.ResolvedResult.Item;
IClass EmbeddingClass = node.EmbeddingClass;
ISealableDictionary <string, IImportedClass> ClassTable = EmbeddingClass.ImportedClassTable;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = EmbeddingClass.FeatureTable;
IFeature InnerFeature = node.EmbeddingFeature;
if (InnerFeature is IIndexerFeature AsIndexerFeature)
{
IFeatureInstance Instance = FeatureTable[AsIndexerFeature.ValidFeatureName.Item];
if (!Instance.FindPrecursor(node.AncestorType, ErrorList, node, out IFeatureInstance SelectedPrecursor))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
IList <ISealableList <IParameter> > ResultTableList = new List <ISealableList <IParameter> >();
ICompiledFeature OperatorFeature = SelectedPrecursor.Feature;
IIndexerType AsIndexerType = OperatorFeature.ResolvedAgentType.Item as IIndexerType;
Debug.Assert(AsIndexerType != null);
ParameterTableList.Add(AsIndexerType.ParameterTable);
ResultTableList.Add(new SealableList <IParameter>());
if (!Argument.CheckAssignmentConformance(ParameterTableList, ResultTableList, node.ArgumentList, SourceExpression, AsIndexerType.ResolvedEntityType.Item, ErrorList, node, out IFeatureCall FeatureCall))
{
return(false);
}
IResultException ResolvedException = new ResultException();
ResultException.Merge(ResolvedException, SourceExpression.ResolvedException.Item);
foreach (IArgument Item in node.ArgumentList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
ResultException.Merge(ResolvedException, AsIndexerType.SetExceptionIdentifierList);
data = new Tuple <IResultException, IFeatureCall>(ResolvedException, FeatureCall);
}
else
{
AddSourceError(new ErrorInvalidInstruction(node));
return(false);
}
return(Success);
}
private static bool CreateFeature(ICSharpClass owner, IFeatureInstance instance, out ICSharpFeature result)
{
result = null;
bool IsHandled = false;
ICompiledFeature SourceFeature = instance.Feature;
switch (SourceFeature)
{
case IAttributeFeature AsAttributeFeature:
result = CSharpAttributeFeature.Create(owner, instance, AsAttributeFeature);
IsHandled = true;
break;
case IConstantFeature AsConstantFeature:
result = CSharpConstantFeature.Create(owner, instance, AsConstantFeature);
IsHandled = true;
break;
case ICreationFeature AsCreationFeature:
result = CSharpCreationFeature.Create(owner, instance, AsCreationFeature);
IsHandled = true;
break;
case IFunctionFeature AsFunctionFeature:
result = CSharpFunctionFeature.Create(owner, instance, AsFunctionFeature);
IsHandled = true;
break;
case IIndexerFeature AsIndexerFeature:
result = CSharpIndexerFeature.Create(owner, instance, AsIndexerFeature);
IsHandled = true;
break;
case IProcedureFeature AsProcedureFeature:
result = CSharpProcedureFeature.Create(owner, instance, AsProcedureFeature);
IsHandled = true;
break;
case IPropertyFeature AsPropertyFeature:
result = CSharpPropertyFeature.Create(owner, instance, AsPropertyFeature);
IsHandled = true;
break;
case IScopeAttributeFeature AsScopeAttributeFeature:
result = CSharpScopeAttributeFeature.Create(owner, AsScopeAttributeFeature);
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
return(result != null);
}
/// <summary>
/// Initializes the feature precursor hierarchy.
/// </summary>
/// <param name="context">The initialization context.</param>
public override void InitHierarchy(ICSharpContext context)
{
if (Instance.OriginalPrecursor.IsAssigned)
{
IPrecursorInstance Item = Instance.OriginalPrecursor.Item;
ICompiledFeature PrecursorFeature = Item.Precursor.Feature;
OriginalPrecursor = context.GetFeature(PrecursorFeature) as ICSharpPropertyFeature;
Debug.Assert(OriginalPrecursor != null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FeatureInstance"/> class.
/// </summary>
/// <param name="owner">The class with the instance. Can be different than the class that defines the feature.</param>
/// <param name="feature">The feature.</param>
/// <param name="isKept">Inherited with a keep clause.</param>
/// <param name="isDiscontinued">Inherited with a discontinue clause.</param>
public FeatureInstance(IClass owner, ICompiledFeature feature, bool isKept, bool isDiscontinued)
{
Debug.Assert(owner != null);
Debug.Assert(feature != null);
Owner = owner;
Feature = feature;
IsForgotten = feature.IsDeferredFeature;
IsKept = isKept;
IsDiscontinued = isDiscontinued;
InheritBySideAttribute = false;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(INewExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item4;
ICompiledFeature ResolvedFinalFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature>)data).Item5;
node.ResolvedResult.Item = ResolvedResult;
node.ConstantSourceList.AddRange(ConstantSourceList);
node.ConstantSourceList.Seal();
node.ExpressionConstant.Item = ExpressionConstant;
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(ICommandInstruction node, object data)
{
IResultException ResolvedException = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item1;
ICompiledFeature SelectedFeature = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item2;
ICommandOverloadType SelectedOverload = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item3;
IFeatureCall FeatureCall = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item4;
IProcedureType CommandFinalType = ((Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>)data).Item5;
node.ResolvedException.Item = ResolvedException;
node.SelectedFeature.Item = SelectedFeature;
node.SelectedOverload.Item = SelectedOverload;
node.FeatureCall.Item = FeatureCall;
node.CommandFinalType.Item = CommandFinalType;
}
private static bool ResolveCall(IPrecursorExpression node, IFeatureInstance selectedPrecursor, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList)
{
selectedParameterList = null;
selectedResultList = null;
resolvedArgumentList = null;
IList <IArgument> ArgumentList = node.ArgumentList;
ICompiledFeature OperatorFeature = selectedPrecursor.Feature;
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
bool IsHandled = false;
bool Success = false;
switch (OperatorFeature)
{
case IAttributeFeature AsAttributeFeature:
case ICreationFeature AsCreationFeature:
case IProcedureFeature AsProcedureFeature:
case IIndexerFeature AsIndexerFeature:
errorList.AddError(new ErrorInvalidExpression(node));
IsHandled = true;
break;
case IConstantFeature AsConstantFeature:
Success = ResolveCallClass(node, selectedPrecursor, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList);
IsHandled = true;
break;
case IFunctionFeature AsFunctionFeature:
IFunctionType FunctionType = AsFunctionFeature.ResolvedAgentType.Item as IFunctionType;
Debug.Assert(FunctionType != null);
Success = ResolveCallFunction(node, selectedPrecursor, FunctionType, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList);
IsHandled = true;
break;
case IPropertyFeature AsPropertyFeature:
IPropertyType PropertyType = AsPropertyFeature.ResolvedAgentType.Item as IPropertyType;
Debug.Assert(PropertyType != null);
Success = ResolveCallProperty(node, selectedPrecursor, PropertyType, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList);
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
return(Success);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpQueryExpression"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly expression from which the C# expression is created.</param>
protected CSharpQueryExpression(ICSharpContext context, IQueryExpression source)
: base(context, source)
{
FeatureCall = new CSharpFeatureCall(context, source.FeatureCall.Item);
if (Source.ResolvedFinalFeature.IsAssigned)
{
ICompiledFeature ResolvedFeature = Source.ResolvedFinalFeature.Item;
if (ResolvedFeature is IScopeAttributeFeature AsScopeAttributeFeature)
{
ICSharpClass Owner = context.GetClass(source.EmbeddingClass);
Feature = CSharpScopeAttributeFeature.Create(context, Owner, AsScopeAttributeFeature);
}
else
{
Feature = context.GetFeature(Source.ResolvedFinalFeature.Item);
}
}
if (Source.ResolvedFinalDiscrete.IsAssigned)
{
DiscreteOwner = context.GetClass(Source.ResolvedFinalDiscrete.Item.EmbeddingClass);
foreach (ICSharpDiscrete Item in DiscreteOwner.DiscreteList)
{
if (Item.Source == Source.ResolvedFinalDiscrete.Item)
{
Debug.Assert(Discrete == null);
Discrete = Item;
}
}
}
Debug.Assert((Feature != null && Discrete == null) || (Feature == null && Discrete != null));
if (Source.SelectedOverloadType.IsAssigned)
{
Debug.Assert(Feature != null);
SelectedOverloadType = CSharpQueryOverloadType.Create(context, Source.SelectedOverloadType.Item, Feature.Owner);
}
else
{
SelectedOverloadType = null;
}
Query = CSharpQualifiedName.Create(context, (IQualifiedName)Source.Query, Feature, Discrete, source.InheritBySideAttribute);
}
private bool CheckPrecursorBodiesHaveAncestor(ISealableDictionary <IFeatureName, InheritedInstanceInfo> byNameTable, IErrorList errorList)
{
foreach (KeyValuePair <IFeatureName, InheritedInstanceInfo> ImportedEntry in byNameTable)
{
IFeatureName ImportedKey = ImportedEntry.Key;
InheritedInstanceInfo ImportedInstance = ImportedEntry.Value;
if (ImportedInstance.EffectiveInstance.IsAssigned)
{
InstanceNameInfo Item = ImportedInstance.EffectiveInstance.Item;
ICompiledFeature EffectiveFeature = Item.Instance.Feature;
if (EffectiveFeature.HasPrecursorBody)
{
bool HasEffectiveAncestor = false;
foreach (InstanceNameInfo AncestorItem in ImportedInstance.PrecursorInstanceList)
{
if (AncestorItem == Item)
{
continue;
}
ICompiledFeature AncestorEffectiveFeature = AncestorItem.Instance.Feature;
if (AncestorEffectiveFeature.IsDeferredFeature)
{
continue;
}
HasEffectiveAncestor = true;
}
if (!HasEffectiveAncestor)
{
IFeature AsFeature = EffectiveFeature as IFeature;
Debug.Assert(AsFeature != null);
errorList.AddError(new ErrorMissingAncestor(AsFeature, Item.Name.Name));
return(false);
}
}
}
}
return(true);
}
/// <summary>
/// Checks if a property should declare a side-by-side private field of the same type due to inherited ancestors.
/// </summary>
/// <param name="globalFeatureTable">The table of all known features.</param>
public void CheckInheritSideBySideAttribute(IDictionary <ICompiledFeature, ICSharpFeature> globalFeatureTable)
{
if (HasSideBySideAttribute)
{
foreach (IPrecursorInstance Item in Instance.PrecursorList)
{
ICompiledFeature PrecursorFeature = Item.Precursor.Feature;
Debug.Assert(globalFeatureTable.ContainsKey(PrecursorFeature));
ICSharpPropertyFeature PrecursorPropertyFeature = globalFeatureTable[PrecursorFeature] as ICSharpPropertyFeature;
Debug.Assert(PrecursorPropertyFeature != null);
if (IsOverride && PrecursorPropertyFeature.HasSideBySideAttribute)
{
Instance.SetInheritBySideAttribute(true);
break;
}
}
}
}
/// <summary>
/// Checks if an intermediate step in a path to a target type is resolved.
/// </summary>
/// <param name="item">The current step.</param>
/// <param name="nextItem">The step after <paramref name="item"/>.</param>
/// <param name="localEntityList">The list of available local variables.</param>
/// <param name="featureTable">The feature table to use.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="isInterrupted">Set if an error is found.</param>
/// <returns>False to stop; True to continue with the next step.</returns>
public static bool IsPathItemReady(IIdentifier item, IIdentifier nextItem, ref List <IEntityDeclaration> localEntityList, ref ISealableDictionary <IFeatureName, IFeatureInstance> featureTable, IErrorList errorList, ref bool isInterrupted)
{
Debug.Assert(featureTable.IsSealed);
Debug.Assert(item.ValidText.IsAssigned);
string Text = item.ValidText.Item;
bool IsLocal = IsLocalEntity(Text, localEntityList, out IEntityDeclaration Entity);
bool IsFeature = FeatureName.TableContain(featureTable, Text, out IFeatureName ItemName, out IFeatureInstance ItemInstance);
// Check that the name is known in the table of features for the current step.
if (!IsLocal && !IsFeature)
{
errorList.AddError(new ErrorUnknownIdentifier(item, Text));
isInterrupted = true;
return(false);
}
bool IsReady = false;
ICompiledType ItemType = null;
if (IsLocal)
{
IsReady = Entity.ValidEntity.IsAssigned && Entity.ValidEntity.Item.ResolvedEffectiveType.IsAssigned;
ItemType = IsReady ? Entity.ValidEntity.Item.ResolvedEffectiveType.Item : null;
}
else
{
ICompiledFeature ItemFeature = ItemInstance.Feature;
IsReady = IsPathGlobalItemReady(ItemFeature, nextItem, errorList, ref isInterrupted, out ItemType);
}
if (IsReady)
{
Debug.Assert(ItemType != null);
featureTable = ItemType.FeatureTable;
IsReady = featureTable.IsSealed;
}
return(IsReady);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(IEntityExpression node, object data)
{
IResultType ResolvedResult = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item1;
IResultException ResolvedException = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item2;
ISealableList <IExpression> ConstantSourceList = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item3;
ILanguageConstant ExpressionConstant = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item4;
ICompiledFeature ResolvedFinalFeature = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item5;
IDiscrete ResolvedFinalDiscrete = ((Tuple <IResultType, IResultException, ISealableList <IExpression>, ILanguageConstant, ICompiledFeature, IDiscrete>)data).Item6;
node.ResolvedException.Item = ResolvedException;
if (ResolvedFinalFeature != null)
{
node.ResolvedFinalFeature.Item = ResolvedFinalFeature;
}
if (ResolvedFinalDiscrete != null)
{
node.ResolvedFinalDiscrete.Item = ResolvedFinalDiscrete;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpAgentExpression"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="source">The Easly expression from which the C# expression is created.</param>
protected CSharpAgentExpression(ICSharpContext context, IAgentExpression source)
: base(context, source)
{
string DelegatedName = ((IIdentifier)Source.Delegated).ValidText.Item;
if (source.BaseType.IsAssigned)
{
IObjectType SourceBaseType = (IObjectType)source.BaseType.Item;
ICompiledType ResolvedBaseType = SourceBaseType.ResolvedType.Item;
BaseType = CSharpType.Create(context, ResolvedBaseType) as ICSharpTypeWithFeature;
Debug.Assert(BaseType != null);
EffectiveBaseType = BaseType;
foreach (ICSharpClassType ClassType in BaseType.ConformingClassTypeList)
{
foreach (KeyValuePair <IFeatureName, IFeatureInstance> Entry in ClassType.Source.FeatureTable)
{
if (Entry.Key.Name == DelegatedName)
{
Debug.Assert(Delegated == null);
ICompiledFeature Feature = Entry.Value.Feature;
Delegated = context.GetFeature(Feature) as ICSharpFeatureWithName;
if (ResolvedBaseType is IFormalGenericType)
{
EffectiveBaseType = ClassType;
}
}
}
}
}
else
{
Delegated = context.GetFeature(source.ResolvedFeature.Item) as ICSharpFeatureWithName;
}
Debug.Assert(Delegated != null);
}
private static bool CheckRename(ICSharpClass cSharpClass, IErrorList errorList)
{
bool Result = true;
foreach (IInheritance InheritanceItem in cSharpClass.Source.InheritanceList)
{
IClassType ParentType = InheritanceItem.ResolvedClassParentType.Item;
IClass ParentClass = ParentType.BaseClass;
bool BadRename = false;
foreach (IRename RenameItem in InheritanceItem.RenameList)
{
string ValidSourceText = RenameItem.ValidSourceText.Item;
if (!FeatureName.TableContain(ParentClass.FeatureTable, ValidSourceText, out IFeatureName Key, out IFeatureInstance Instance))
{
BadRename = true;
break;
}
IClass SourceClass = Instance.Owner;
ICompiledFeature SourceFeature = Instance.Feature;
CSharpExports ExportStatus = GetExportStatus(Key, SourceClass, cSharpClass.Source.ExportTable, (IFeature)SourceFeature);
if (ExportStatus == CSharpExports.Public && !(SourceFeature is ICreationFeature))
{
BadRename = true;
break;
}
}
if (BadRename)
{
errorList.AddError(new ErrorInvalidRename(InheritanceItem));
}
Result &= !BadRename;
}
return(Result);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpCommandInstruction"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="parentFeature">The parent feature.</param>
/// <param name="source">The Easly instruction from which the C# instruction is created.</param>
protected CSharpCommandInstruction(ICSharpContext context, ICSharpFeature parentFeature, ICommandInstruction source)
: base(context, parentFeature, source)
{
Command = CSharpQualifiedName.Create(context, (IQualifiedName)source.Command, parentFeature, null, false);
FeatureCall = new CSharpFeatureCall(context, source.FeatureCall.Item);
ICompiledFeature SourceFeature = source.SelectedFeature.Item;
if (SourceFeature is IScopeAttributeFeature AsScopeAttributeFeature)
{
FinalFeature = CSharpScopeAttributeFeature.Create(null, AsScopeAttributeFeature);
}
else
{
FinalFeature = context.GetFeature(SourceFeature);
}
ICompiledTypeWithFeature ResolvedBaseType = Source.CommandFinalType.Item.ResolvedBaseType.Item;
FinalType = CSharpType.Create(context, ResolvedBaseType) as ICSharpTypeWithFeature;
Debug.Assert(FinalType != null);
IList <ICSharpClassType> ConformingClassTypeList = FinalType.ConformingClassTypeList;
bool InheritFromDotNetEvent = false;
bool IsNumberType = false;
foreach (ICSharpClassType Item in ConformingClassTypeList)
{
ICSharpClass CallClass = Item.Class;
InheritFromDotNetEvent |= CallClass.InheritFromDotNetEvent;
IsNumberType = Item.IsNumberType;
}
SkipLastInPath = InheritFromDotNetEvent;
IsCallingNumberFeature = IsNumberType;
}
private static bool ResolveCallProperty(IPrecursorExpression node, IFeatureInstance selectedPrecursor, IPropertyType callType, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList)
{
selectedParameterList = null;
selectedResultList = null;
resolvedArgumentList = null;
IList <IArgument> ArgumentList = node.ArgumentList;
if (ArgumentList.Count > 0)
{
errorList.AddError(new ErrorInvalidExpression(node));
return(false);
}
else
{
ICompiledFeature OperatorFeature = selectedPrecursor.Feature;
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
IPropertyFeature Property = (IPropertyFeature)OperatorFeature;
string PropertyName = ((IFeatureWithName)Property).EntityName.Text;
resolvedExpression.ResolvedResult = new ResultType(callType.ResolvedEntityTypeName.Item, callType.ResolvedEntityType.Item, PropertyName);
resolvedExpression.ResolvedException = new ResultException();
if (Property.GetterBody.IsAssigned)
{
IBody GetterBody = (IBody)Property.GetterBody.Item;
resolvedExpression.ResolvedException = new ResultException(GetterBody.ExceptionIdentifierList);
}
selectedParameterList = new SealableList <IParameter>();
selectedResultList = new SealableList <IParameter>();
resolvedArgumentList = new List <IExpressionType>();
return(true);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpAssignmentInstruction"/> class.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="parentFeature">The parent feature.</param>
/// <param name="source">The Easly instruction from which the C# instruction is created.</param>
protected CSharpAssignmentInstruction(ICSharpContext context, ICSharpFeature parentFeature, IAssignmentInstruction source)
: base(context, parentFeature, source)
{
SourceExpression = CSharpExpression.Create(context, (IExpression)Source.Source);
foreach (IQualifiedName Destination in source.DestinationList)
{
ICompiledFeature SourceFeature = source.FinalFeatureTable[Destination];
ICSharpFeature FinalFeature;
if (SourceFeature is IScopeAttributeFeature AsScopeAttributeFeature)
{
FinalFeature = CSharpScopeAttributeFeature.Create(null, AsScopeAttributeFeature);
}
else
{
FinalFeature = context.GetFeature(SourceFeature);
}
ICSharpQualifiedName NewDestination = CSharpQualifiedName.Create(context, Destination, FinalFeature, null, false);
DestinationList.Add(NewDestination);
}
}
private static bool ResolveFeature(IQueryExpression node, IErrorList errorList, ICompiledFeature resolvedFinalFeature, ITypeName finalTypeName, ICompiledType finalType, ref ResolvedExpression resolvedExpression)
{
ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node);
IQualifiedName Query = (IQualifiedName)node.Query;
IList <IArgument> ArgumentList = node.ArgumentList;
IClass EmbeddingClass = node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
IList <IIdentifier> ValidPath = Query.ValidPath.Item;
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList))
{
return(false);
}
IIdentifier LastIdentifier = ValidPath[ValidPath.Count - 1];
string ValidText = LastIdentifier.ValidText.Item;
bool IsHandled = false;
bool Success = true;
switch (finalType)
{
case IFunctionType AsFunctionType:
if (!ResolveFeatureAsFunctionType(node, errorList, resolvedFinalFeature, MergedArgumentList, TypeArgumentStyle, AsFunctionType, ref resolvedExpression))
{
return(false);
}
IsHandled = true;
break;
case IProcedureType AsProcedureType:
case IIndexerType AsIndexerType:
errorList.AddError(new ErrorInvalidExpression(node));
Success = false;
IsHandled = true;
break;
case IPropertyType AsPropertyType:
resolvedExpression.ResolvedResult = new ResultType(AsPropertyType.ResolvedEntityTypeName.Item, AsPropertyType.ResolvedEntityType.Item, ValidText);
resolvedExpression.ResolvedException = new ResultException(AsPropertyType.GetExceptionIdentifierList);
resolvedExpression.SelectedResultList = new SealableList <IParameter>();
resolvedExpression.FeatureCall = new FeatureCall();
IsHandled = true;
break;
case IClassType AsClassType:
case ITupleType AsTupleType:
resolvedExpression.ResolvedResult = new ResultType(finalTypeName, finalType, ValidText);
resolvedExpression.ResolvedException = new ResultException();
resolvedExpression.SelectedResultList = new SealableList <IParameter>();
resolvedExpression.FeatureCall = new FeatureCall();
IsHandled = true;
break;
case IFormalGenericType AsFormalGenericType:
resolvedExpression.ResolvedResult = new ResultType(finalTypeName, AsFormalGenericType, ValidText);
resolvedExpression.ResolvedException = new ResultException();
resolvedExpression.SelectedResultList = new SealableList <IParameter>();
resolvedExpression.FeatureCall = new FeatureCall();
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
if (!Success)
{
return(false);
}
ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Query.ValidResultTypePath.Item);
IsHandled = false;
switch (resolvedFinalFeature)
{
case IConstantFeature AsConstantFeature:
IExpression ConstantValue = (IExpression)AsConstantFeature.ConstantValue;
resolvedExpression.ConstantSourceList.Add(ConstantValue);
IsHandled = true;
break;
case IFunctionFeature AsFunctionFeature:
Argument.AddConstantArguments(node, resolvedExpression.ResolvedResult, ArgumentList, resolvedExpression.ConstantSourceList, out ILanguageConstant ExpressionConstant);
resolvedExpression.ExpressionConstant = ExpressionConstant;
IsHandled = true;
break;
case IAttributeFeature AsAttributeFeature:
case IPropertyFeature AsPropertyFeature:
case IScopeAttributeFeature AsScopeAttributeFeature:
resolvedExpression.ExpressionConstant = Expression.GetDefaultConstant(node, resolvedExpression.ResolvedResult);
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
return(true);
}
private static bool ResolveFeatureAsFunctionType(IQueryExpression node, IErrorList errorList, ICompiledFeature resolvedFinalFeature, List <IExpressionType> mergedArgumentList, TypeArgumentStyles typeArgumentStyle, IFunctionType finalType, ref ResolvedExpression resolvedExpression)
{
// IScopeAttributeFeature is the case of an agent.
IList <IArgument> ArgumentList = node.ArgumentList;
IFunctionFeature AsFunctionFeature = resolvedFinalFeature as IFunctionFeature;
IScopeAttributeFeature AsScopeAttributeFeature = resolvedFinalFeature as IScopeAttributeFeature;
Debug.Assert(AsFunctionFeature != null || AsScopeAttributeFeature != null);
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
foreach (IQueryOverloadType Overload in finalType.OverloadList)
{
ParameterTableList.Add(Overload.ParameterTable);
}
int SelectedIndex;
if (!Argument.ArgumentsConformToParameters(ParameterTableList, mergedArgumentList, typeArgumentStyle, errorList, node, out SelectedIndex))
{
return(false);
}
resolvedExpression.SelectedOverloadType = finalType.OverloadList[SelectedIndex];
resolvedExpression.ResolvedResult = new ResultType(resolvedExpression.SelectedOverloadType.ResultTypeList);
resolvedExpression.ResolvedException = new ResultException(resolvedExpression.SelectedOverloadType.ExceptionIdentifierList);
if (AsFunctionFeature != null)
{
Debug.Assert(AsFunctionFeature.OverloadList.Count == finalType.OverloadList.Count);
Debug.Assert(AsFunctionFeature.ResolvedAgentType.IsAssigned);
Debug.Assert(AsFunctionFeature.ResolvedAgentType.Item == finalType);
resolvedExpression.SelectedOverload = AsFunctionFeature.OverloadList[SelectedIndex];
resolvedExpression.SelectedResultList = resolvedExpression.SelectedOverload.ResultTable;
resolvedExpression.FeatureCall = new FeatureCall(resolvedExpression.SelectedOverload.ParameterTable, resolvedExpression.SelectedOverload.ResultTable, ArgumentList, mergedArgumentList, typeArgumentStyle);
}
else
{
resolvedExpression.SelectedResultList = resolvedExpression.SelectedOverloadType.ResultTable;
resolvedExpression.FeatureCall = new FeatureCall(resolvedExpression.SelectedOverloadType.ParameterTable, resolvedExpression.SelectedOverloadType.ResultTable, ArgumentList, mergedArgumentList, typeArgumentStyle);
}
return(true);
}
/// <summary>
/// Finds the matching nodes of a <see cref="IAgentExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedResult">The expression result types upon return.</param>
/// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
/// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
/// <param name="expressionConstant">The constant value upon return, if any.</param>
/// <param name="resolvedFeature">The feature found upon return.</param>
public static bool ResolveCompilerReferences(IAgentExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out ICompiledFeature resolvedFeature)
{
resolvedResult = null;
resolvedException = null;
constantSourceList = new SealableList <IExpression>();
expressionConstant = NeutralLanguageConstant.NotConstant;
resolvedFeature = null;
IIdentifier Delegated = (IIdentifier)node.Delegated;
Debug.Assert(Delegated.ValidText.IsAssigned);
string ValidText = Delegated.ValidText.Item;
IFeatureInstance FeatureInstance;
if (node.BaseType.IsAssigned)
{
IObjectType BaseType = (IObjectType)node.BaseType.Item;
ICompiledType ResolvedBaseType = BaseType.ResolvedType.Item;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = null;
switch (ResolvedBaseType)
{
case IClassType AsClassType:
FeatureTable = AsClassType.FeatureTable;
break;
case IFormalGenericType AsFormalGenericType:
foreach (IConstraint Item in AsFormalGenericType.FormalGeneric.ConstraintList)
{
if (Item.ResolvedTypeWithRename.Item is IClassType Parent)
{
FeatureTable = Parent.FeatureTable;
if (FeatureName.TableContain(FeatureTable, ValidText, out IFeatureName ParentKey, out IFeatureInstance ParentFeatureInstance))
{
break;
}
}
}
break;
}
if (FeatureTable == null)
{
errorList.AddError(new ErrorClassTypeRequired(node));
return(false);
}
if (!FeatureName.TableContain(FeatureTable, ValidText, out IFeatureName Key, out FeatureInstance))
{
errorList.AddError(new ErrorUnknownIdentifier(node, ValidText));
return(false);
}
}
else
{
IClass EmbeddingClass = node.EmbeddingClass;
if (!FeatureName.TableContain(EmbeddingClass.FeatureTable, ValidText, out IFeatureName Key, out FeatureInstance))
{
errorList.AddError(new ErrorUnknownIdentifier(node, ValidText));
return(false);
}
}
Debug.Assert(FeatureInstance.Feature != null);
resolvedFeature = FeatureInstance.Feature;
resolvedResult = new ResultType(resolvedFeature.ResolvedAgentTypeName.Item, resolvedFeature.ResolvedAgentType.Item, string.Empty);
resolvedException = new ResultException();
expressionConstant = new AgentLanguageConstant(resolvedFeature);
#if COVERAGE
Debug.Assert(!node.IsComplex);
#endif
return(true);
}
/// <summary>
/// Gets the C# feature from the source feature.
/// </summary>
/// <param name="sourceFeature">The source feature.</param>
public ICSharpFeature GetFeature(ICompiledFeature sourceFeature)
{
Debug.Assert(FeatureTable.ContainsKey(sourceFeature));
return(FeatureTable[sourceFeature]);
}
/// <summary>
/// Gets the object a path is refering to.
/// </summary>
/// <param name="baseClass">The class where the path is used.</param>
/// <param name="baseType">The type at the start of the path.</param>
/// <param name="localScope">The local scope.</param>
/// <param name="validPath">The path.</param>
/// <param name="index">Index of the current identifier in the path.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="finalFeature">The feature at the end of the path, if any, upon return.</param>
/// <param name="finalDiscrete">The discrete at the end of the path, if any, upon return.</param>
/// <param name="finalTypeName">The type name of the result.</param>
/// <param name="finalType">The type of the result.</param>
/// <param name="inheritBySideAttribute">Inherited from an effective body.</param>
public static bool GetQualifiedPathFinalType(IClass baseClass, ICompiledType baseType, ISealableDictionary <string, IScopeAttributeFeature> localScope, IList <IIdentifier> validPath, int index, IErrorList errorList, out ICompiledFeature finalFeature, out IDiscrete finalDiscrete, out ITypeName finalTypeName, out ICompiledType finalType, out bool inheritBySideAttribute)
{
finalFeature = null;
finalDiscrete = null;
finalTypeName = null;
finalType = null;
inheritBySideAttribute = false;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = baseType.FeatureTable;
IIdentifier ValidIdentifier = validPath[index];
string ValidText = ValidIdentifier.ValidText.Item;
if (index == 0 && localScope.ContainsKey(ValidText))
{
return(GetQualifiedPathFinalTypeFromLocal(baseClass, baseType, localScope, validPath, index, errorList, out finalFeature, out finalDiscrete, out finalTypeName, out finalType, out inheritBySideAttribute));
}
else if (FeatureName.TableContain(FeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Instance))
{
return(GetQualifiedPathFinalTypeAsFeature(baseClass, baseType, localScope, validPath, index, errorList, Instance, out finalFeature, out finalDiscrete, out finalTypeName, out finalType, out inheritBySideAttribute));
}
