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)); }