private bool CheckIndexerKind(IIndexerFeature node, out BaseNode.UtilityType indexerKind)
{
bool Success = true;
indexerKind = (BaseNode.UtilityType)(-1);
if (node.GetterBody.IsAssigned && node.SetterBody.IsAssigned)
{
indexerKind = BaseNode.UtilityType.ReadWrite;
ICompiledBody AsCompiledGetter = (ICompiledBody)node.GetterBody.Item;
ICompiledBody AsCompiledSetter = (ICompiledBody)node.SetterBody.Item;
if (AsCompiledGetter.IsDeferredBody != AsCompiledSetter.IsDeferredBody)
{
AddSourceError(new ErrorIndexerBodyTypeMismatch(node));
Success = false;
}
}
else if (node.GetterBody.IsAssigned)
{
indexerKind = BaseNode.UtilityType.ReadOnly;
}
else if (node.SetterBody.IsAssigned)
{
indexerKind = BaseNode.UtilityType.WriteOnly;
}
else
{
AddSourceError(new ErrorIndexerMissingBody(node));
Success = 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(IFunctionFeature node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IName EntityName = (IName)((IFeatureWithName)node).EntityName;
// This is ensured because the root node is valid.
Debug.Assert(node.OverloadList.Count > 0);
IQueryOverload FirstOverload = node.OverloadList[0];
ICompiledBody FirstOverloadBody = (ICompiledBody)FirstOverload.QueryBody;
for (int i = 1; i < node.OverloadList.Count; i++)
{
IQueryOverload ThisOverload = node.OverloadList[i];
ICompiledBody ThisOverloadBody = (ICompiledBody)ThisOverload.QueryBody;
if (ThisOverloadBody.IsDeferredBody != FirstOverloadBody.IsDeferredBody)
{
ErrorList.AddError(new ErrorBodyTypeMismatch(ThisOverload, EntityName.ValidText.Item));
Success = false;
break;
}
}
IErrorList CheckErrorList = new ErrorList();
IList <IQueryOverloadType> OverloadTypeList = new List <IQueryOverloadType>();
foreach (IQueryOverload Overload in node.OverloadList)
{
Debug.Assert(Overload.ResolvedAssociatedType.IsAssigned);
OverloadTypeList.Add(Overload.ResolvedAssociatedType.Item);
}
if (!Feature.DisjoinedParameterCheck(OverloadTypeList, CheckErrorList))
{
Debug.Assert(!CheckErrorList.IsEmpty);
AddSourceErrorList(CheckErrorList);
Success = false;
}
return(Success);
}
/// <summary>
/// Creates a new C# body.
/// </summary>
/// <param name="context">The creation context.</param>
/// <param name="parentFeature">The parent feature.</param>
/// <param name="source">The Easly body from which the C# body is created.</param>
public static ICSharpBody Create(ICSharpContext context, ICSharpFeature parentFeature, ICompiledBody source)
{
ICSharpBody Result = null;
switch (source)
{
case IDeferredBody AsDeferredBody:
Result = CSharpDeferredBody.Create(context, parentFeature, AsDeferredBody);
break;
case IEffectiveBody AsEffectiveBody:
Result = CSharpEffectiveBody.Create(context, parentFeature, AsEffectiveBody);
break;
case IExternBody AsExternBody:
Result = CSharpExternBody.Create(context, parentFeature, AsExternBody);
break;
case IPrecursorBody AsPrecursorBody:
Result = CSharpPrecursorBody.Create(context, parentFeature, AsPrecursorBody);
break;
}
Debug.Assert(Result != null);
return(Result);
}
/// <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(IPropertyFeature node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
data = null;
bool Success = true;
IClass EmbeddingClass = node.EmbeddingClass;
IObjectType TypeToResolve = (IObjectType)node.EntityType;
IScopeAttributeFeature Result = ScopeAttributeFeature.CreateResultFeature(TypeToResolve, EmbeddingClass, node);
IScopeAttributeFeature Value = ScopeAttributeFeature.CreateValueFeature(TypeToResolve, EmbeddingClass, node);
string NameResult = Result.ValidFeatureName.Item.Name;
string NameValue = Value.ValidFeatureName.Item.Name;
ISealableDictionary <string, IScopeAttributeFeature> CheckedGetScope = new SealableDictionary <string, IScopeAttributeFeature>();
CheckedGetScope.Add(NameResult, Result);
ISealableDictionary <string, IScopeAttributeFeature> CheckedSetScope = new SealableDictionary <string, IScopeAttributeFeature>();
CheckedSetScope.Add(NameValue, Value);
IList <string> ConflictList = new List <string>();
ScopeHolder.RecursiveCheck(CheckedGetScope, node.InnerScopes, ConflictList);
ScopeHolder.RecursiveCheck(CheckedSetScope, node.InnerScopes, ConflictList);
// This has been checked in another rule.
Debug.Assert(!ConflictList.Contains(NameResult));
Debug.Assert(!ConflictList.Contains(NameValue));
IName PropertyName = (IName)((IFeatureWithName)node).EntityName;
if (node.GetterBody.IsAssigned && node.SetterBody.IsAssigned)
{
ICompiledBody AsCompiledGetter = (ICompiledBody)node.GetterBody.Item;
ICompiledBody AsCompiledSetter = (ICompiledBody)node.SetterBody.Item;
if (AsCompiledGetter.IsDeferredBody != AsCompiledSetter.IsDeferredBody)
{
AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item));
Success = false;
}
if (node.PropertyKind != BaseNode.UtilityType.ReadWrite)
{
AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item));
Success = false;
}
}
else if (node.GetterBody.IsAssigned)
{
if (node.PropertyKind == BaseNode.UtilityType.WriteOnly)
{
AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item));
Success = false;
}
}
else if (node.SetterBody.IsAssigned)
{
if (node.PropertyKind == BaseNode.UtilityType.ReadOnly)
{
AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item));
Success = false;
}
}
if (Success)
{
data = new Tuple <IScopeAttributeFeature, IScopeAttributeFeature>(Result, Value);
}
return(Success);
}
