/// <summary>
/// Sets the <see cref="ICSharpOutputNode.WriteDown"/> flag.
/// </summary>
public override void SetWriteDown()
{
if (WriteDown)
{
return;
}
WriteDown = true;
FeatureCall.SetWriteDown();
}
/// <summary>
/// Sets the <see cref="ICSharpOutputNode.WriteDown"/> flag.
/// </summary>
public override void SetWriteDown()
{
if (WriteDown)
{
return;
}
WriteDown = true;
RightExpression.SetWriteDown();
FeatureCall.SetWriteDown();
}
/// <summary>
/// Sets the <see cref="ICSharpOutputNode.WriteDown"/> flag.
/// </summary>
public override void SetWriteDown()
{
if (WriteDown)
{
return;
}
WriteDown = true;
if (Feature != null)
{
Feature.SetWriteDown();
FeatureCall.SetWriteDown();
}
if (Discrete != null)
{
Discrete.SetWriteDown();
}
}
/// <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(IThrowInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IObjectType ThrowExceptionType = (IObjectType)node.ExceptionType;
ICompiledType ResolvedType = ThrowExceptionType.ResolvedType.Item;
IIdentifier CreationRoutine = (IIdentifier)node.CreationRoutine;
string ValidText = CreationRoutine.ValidText.Item;
IClass EmbeddingClass = node.EmbeddingClass;
if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Exception.Guid, node, out ITypeName ExceptionTypeName, out ICompiledType ExceptionType))
{
AddSourceError(new ErrorExceptionTypeMissing(node));
return(false);
}
if (!ObjectType.TypeConformToBase(ResolvedType, ExceptionType, isConversionAllowed: true))
{
AddSourceError(new ErrorExceptionTypeRequired(node));
return(false);
}
if (!FeatureName.TableContain(ResolvedType.FeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Value))
{
AddSourceError(new ErrorUnknownIdentifier(CreationRoutine, ValidText));
return(false);
}
if (Value.Feature is CreationFeature AsCreationFeature)
{
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(node.ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, ErrorList))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
Debug.Assert(AsCreationFeature.ResolvedAgentType.IsAssigned);
ICompiledType FinalType = AsCreationFeature.ResolvedAgentType.Item;
IProcedureType AsProcedureType = FinalType as IProcedureType;
Debug.Assert(AsProcedureType != null);
foreach (ICommandOverloadType Overload in AsProcedureType.OverloadList)
{
ParameterTableList.Add(Overload.ParameterTable);
}
if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, TypeArgumentStyle, ErrorList, node, out int SelectedIndex))
{
return(false);
}
ICommandOverloadType SelectedOverload = AsProcedureType.OverloadList[SelectedIndex];
IResultException ResolvedException = new ResultException();
ResolvedException.Add(ValidText);
Debug.Assert(ResolvedException.At(0).Text == ValidText);
Debug.Assert(ResolvedException.At(0).ValidText.IsAssigned);
Debug.Assert(ResolvedException.At(0).ValidText.Item == ValidText);
foreach (IArgument Item in node.ArgumentList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
ResultException.Merge(ResolvedException, SelectedOverload.ExceptionIdentifierList);
IFeatureCall FeatureCall = new FeatureCall(SelectedOverload.ParameterTable, new List <IParameter>(), node.ArgumentList, MergedArgumentList, TypeArgumentStyle);
data = new Tuple <ICompiledType, IResultException, IFeatureCall>(ResolvedType, ResolvedException, FeatureCall);
}
else
{
AddSourceError(new ErrorCreationFeatureRequired(CreationRoutine, ValidText));
return(false);
}
return(Success);
}
/// <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(IPrecursorInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IClass EmbeddingClass = node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = EmbeddingClass.FeatureTable;
IFeature InnerFeature = node.EmbeddingFeature;
if (InnerFeature is IIndexerFeature AsIndexerFeature)
{
AddSourceError(new ErrorPrecursorNotAllowedInIndexer(node));
return(false);
}
else
{
IFeature AsNamedFeature = InnerFeature;
IFeatureInstance Instance = FeatureTable[AsNamedFeature.ValidFeatureName.Item];
OnceReference <IFeatureInstance> SelectedPrecursor = new OnceReference <IFeatureInstance>();
IList <IPrecursorInstance> PrecursorList = Instance.PrecursorList;
if (node.AncestorType.IsAssigned)
{
IObjectType DeclaredAncestor = (IObjectType)node.AncestorType.Item;
if (DeclaredAncestor.ResolvedType.Item is IClassType AsClassTypeAncestor)
{
foreach (IPrecursorInstance Item in PrecursorList)
{
if (Item.Ancestor.BaseClass == AsClassTypeAncestor.BaseClass)
{
SelectedPrecursor.Item = Item.Precursor;
break;
}
}
}
if (!SelectedPrecursor.IsAssigned)
{
AddSourceError(new ErrorInvalidPrecursor(DeclaredAncestor));
return(false);
}
}
else if (Instance.PrecursorList.Count > 1)
{
AddSourceError(new ErrorInvalidPrecursor(node));
return(false);
}
else if (Instance.PrecursorList.Count == 0)
{
AddSourceError(new ErrorNoPrecursor(node));
return(false);
}
else
{
SelectedPrecursor.Item = Instance.PrecursorList[0].Precursor;
}
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(node.ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, ErrorList))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
ICompiledFeature OperatorFeature = SelectedPrecursor.Item.Feature;
ICompiledType OperatorType = OperatorFeature.ResolvedAgentType.Item;
IList <IIdentifier> PrecursorInstructionException = null;
ISealableList <IParameter> SelectedParameterList = null;
// This has been checked in the type pass.
IProcedureType AsProcedureType = OperatorType as IProcedureType;
Debug.Assert(AsProcedureType != null);
foreach (ICommandOverloadType Overload in AsProcedureType.OverloadList)
{
ParameterTableList.Add(Overload.ParameterTable);
}
if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, TypeArgumentStyle, ErrorList, node, out int SelectedIndex))
{
return(false);
}
ICommandOverloadType SelectedOverload = AsProcedureType.OverloadList[SelectedIndex];
PrecursorInstructionException = SelectedOverload.ExceptionIdentifierList;
SelectedParameterList = SelectedOverload.ParameterTable;
IResultException ResolvedException = new ResultException();
foreach (IArgument Item in node.ArgumentList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
ResultException.Merge(ResolvedException, PrecursorInstructionException);
IFeatureCall FeatureCall = new FeatureCall(SelectedParameterList, new List <IParameter>(), node.ArgumentList, MergedArgumentList, TypeArgumentStyle);
data = new Tuple <IResultException, IFeatureCall>(ResolvedException, FeatureCall);
}
return(Success);
}
/// <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(ICommandInstruction node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IQualifiedName Command = (IQualifiedName)node.Command;
IList <IIdentifier> ValidPath = Command.ValidPath.Item;
IClass EmbeddingClass = node.EmbeddingClass;
IClassType BaseType = EmbeddingClass.ResolvedClassType.Item;
ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node);
if (!ObjectType.GetQualifiedPathFinalType(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, ErrorList, out ICompiledFeature FinalFeature, out IDiscrete FinalDiscrete, out ITypeName FinalTypeName, out ICompiledType FinalType, out bool InheritBySideAttribute))
{
return(false);
}
Debug.Assert(FinalFeature != null);
IList <IArgument> ArgumentList = node.ArgumentList;
List <IExpressionType> MergedArgumentList = new List <IExpressionType>();
if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles ArgumentStyle, ErrorList))
{
return(false);
}
IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();
ICommandOverloadType SelectedOverload = null;
ISealableList <IParameter> SelectedParameterList = null;
IProcedureType CommandFinalType = null;
bool IsHandled = false;
switch (FinalType)
{
case IFunctionType AsFunctionType:
case IPropertyType AsPropertyType:
AddSourceError(new ErrorInvalidInstruction(node));
Success = false;
IsHandled = true;
break;
case IProcedureType AsProcedureType:
foreach (ICommandOverloadType Overload in AsProcedureType.OverloadList)
{
ParameterTableList.Add(Overload.ParameterTable);
}
int SelectedIndex;
if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, ArgumentStyle, ErrorList, node, out SelectedIndex))
{
Success = false;
}
else
{
SelectedOverload = AsProcedureType.OverloadList[SelectedIndex];
SelectedParameterList = ParameterTableList[SelectedIndex];
CommandFinalType = AsProcedureType;
}
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
if (Success)
{
ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Command.ValidResultTypePath.Item);
IResultException ResolvedException = new ResultException();
foreach (IArgument Item in node.ArgumentList)
{
ResultException.Merge(ResolvedException, Item.ResolvedException.Item);
}
IList <IIdentifier> CommandInstructionException = SelectedOverload.ExceptionIdentifierList;
ResultException.Merge(ResolvedException, CommandInstructionException);
IFeatureCall FeatureCall = new FeatureCall(SelectedParameterList, new List <IParameter>(), ArgumentList, MergedArgumentList, ArgumentStyle);
data = new Tuple <IResultException, ICompiledFeature, ICommandOverloadType, IFeatureCall, IProcedureType>(ResolvedException, FinalFeature, SelectedOverload, FeatureCall, CommandFinalType);
}
return(Success);
}
