/// <summary>
/// Initializes a new instance of the <see cref="CSharpOverLoopInstruction"/> 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 CSharpOverLoopInstruction(ICSharpContext context, ICSharpFeature parentFeature, IOverLoopInstruction source)
: base(context, parentFeature, source)
{
OverList = CSharpExpression.Create(context, (IExpression)source.OverList);
LoopInstructions = CSharpScope.Create(context, parentFeature, (IScope)source.LoopInstructions);
foreach (IName Name in source.IndexerList)
{
string IndexerName = Name.ValidText.Item;
IScopeAttributeFeature IndexerFeature = Source.InnerLoopScope[IndexerName];
ICSharpScopeAttributeFeature NewIndexer = CSharpScopeAttributeFeature.Create(context, ParentFeature.Owner, IndexerFeature);
IndexerList.Add(NewIndexer);
}
if (source.ExitEntityName.IsAssigned)
{
ExitEntityName = ((IIdentifier)source.ExitEntityName.Item).ValidText.Item;
}
foreach (IAssertion Item in Source.InvariantList)
{
ICSharpAssertion NewAssertion = CSharpAssertion.Create(context, Item);
InvariantList.Add(NewAssertion);
}
}
private void WriteCSharpImplementationEffective(ICSharpWriter writer, ICSharpEffectiveBody effectiveBody, bool isOverride, string nameString, CSharpExports exportStatus, bool isConstructor, ref bool isFirstFeature, ref bool isMultiline)
{
CSharpArgument.BuildParameterList(writer, ParameterList, out string ParameterEntityList, out string ParameterNameList);
CSharpAssertion.WriteContract(writer, effectiveBody.RequireList, effectiveBody.EnsureList, CSharpContractLocations.Other, true, ref isFirstFeature, ref isMultiline);
bool SkipFirstInstruction = false;
if (isConstructor)
{
WriteCSharpImplementationConstructor(writer, isOverride, nameString, exportStatus, ref isFirstFeature, ref isMultiline, ref SkipFirstInstruction);
}
else
{
string ExportStatusText = CSharpNames.ComposedExportStatus(isOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} void {nameString}({ParameterEntityList})");
}
ICSharpEffectiveBody AsEffectiveBody = Body as ICSharpEffectiveBody;
AsEffectiveBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets, string.Empty, SkipFirstInstruction, new List <string>());
isMultiline = true;
}
/// <summary>
/// Initializes the feature overloads and bodies.
/// </summary>
/// <param name="context">The initialization context.</param>
public override void InitOverloadsAndBodies(ICSharpContext context)
{
Type = CSharpType.Create(context, Source.ResolvedEntityType.Item);
foreach (IAssertion Assertion in Source.EnsureList)
{
ICSharpAssertion NewAssertion = CSharpAssertion.Create(context, Assertion);
EnsureList.Add(NewAssertion);
}
}
private void WriteCSharpImplementationDeferred(ICSharpWriter writer, ICSharpDeferredBody deferredBody, bool isOverride, string nameString, CSharpExports exportStatus, bool isConstructor, ref bool isFirstFeature, ref bool isMultiline)
{
CSharpArgument.BuildParameterList(writer, ParameterList, out string ParameterEntityList, out string ParameterNameList);
CSharpAssertion.WriteContract(writer, deferredBody.RequireList, deferredBody.EnsureList, CSharpContractLocations.Other, true, ref isFirstFeature, ref isMultiline);
string ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} void {nameString}({ParameterEntityList});");
isMultiline = false;
}
private void WriteCSharpImplementation(ICSharpWriter writer, CSharpExports exportStatus, ref bool isFirstFeature, ref bool isMultiline)
{
bool IsEvent = false;
if (Type is ICSharpClassType AsClassType)
{
ICSharpClass Class = AsClassType.Class;
if (Class.InheritFromDotNetEvent)
{
IsEvent = true;
}
}
writer.WriteDocumentation(Source);
CSharpAssertion.WriteContract(writer, new List <ICSharpAssertion>(), EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
string TypeString = Type.Type2CSharpString(writer, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None);
string AttributeString = CSharpNames.ToCSharpIdentifier(Name);
string ExportString = CSharpNames.ComposedExportStatus(false, false, true, exportStatus);
if (IsEvent)
{
writer.WriteIndentedLine($"{ExportString} event {TypeString} {AttributeString};");
}
else if (Type.GetSingletonString(writer, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None, out string SingletonString))
{
writer.WriteIndentedLine($"{ExportString} {TypeString} {AttributeString} {{ get {{ return {SingletonString}; }} }}");
}
else if (EnsureList.Count > 0)
{
writer.WriteIndentedLine($"{ExportString} {TypeString} {AttributeString} {{ get; private set; }}");
writer.WriteIndentedLine($"protected void Set_{AttributeString}({TypeString} value)");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"{AttributeString} = value;");
writer.WriteEmptyLine();
foreach (ICSharpAssertion Assertion in EnsureList)
{
Assertion.WriteCSharp(writer);
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
else
{
writer.WriteIndentedLine($"{ExportString} {TypeString} {AttributeString} {{ get; protected set; }}");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpBody"/> class.
/// </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>
protected CSharpBody(ICSharpContext context, ICSharpFeature parentFeature, IBody source)
{
Debug.Assert(source != null);
ParentFeature = parentFeature;
Source = source;
foreach (IAssertion Assertion in source.RequireList)
{
ICSharpAssertion NewAssertion = CSharpAssertion.Create(context, Assertion);
RequireList.Add(NewAssertion);
}
foreach (IAssertion Assertion in source.EnsureList)
{
ICSharpAssertion NewAssertion = CSharpAssertion.Create(context, Assertion);
EnsureList.Add(NewAssertion);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpForLoopInstruction"/> 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 CSharpForLoopInstruction(ICSharpContext context, ICSharpFeature parentFeature, IForLoopInstruction source)
: base(context, parentFeature, source)
{
foreach (IEntityDeclaration Declaration in source.EntityDeclarationList)
{
ICSharpScopeAttributeFeature NewDeclaration = CSharpScopeAttributeFeature.Create(context, parentFeature.Owner, Declaration.ValidEntity.Item);
EntityDeclarationList.Add(NewDeclaration);
}
foreach (IInstruction Instruction in source.InitInstructionList)
{
ICSharpInstruction NewInstruction = Create(context, parentFeature, Instruction);
InitInstructionList.Add(NewInstruction);
}
WhileCondition = CSharpExpression.Create(context, (IExpression)source.WhileCondition);
foreach (IInstruction Instruction in source.LoopInstructionList)
{
ICSharpInstruction NewInstruction = Create(context, parentFeature, Instruction);
LoopInstructionList.Add(NewInstruction);
}
foreach (IInstruction Instruction in source.IterationInstructionList)
{
ICSharpInstruction NewInstruction = Create(context, parentFeature, Instruction);
IterationInstructionList.Add(NewInstruction);
}
if (source.Variant.IsAssigned)
{
VariantExpression = CSharpExpression.Create(context, (IExpression)source.Variant.Item);
}
foreach (IAssertion Item in Source.InvariantList)
{
ICSharpAssertion NewAssertion = CSharpAssertion.Create(context, Item);
InvariantList.Add(NewAssertion);
}
}
/// <summary>
/// Writes down the C# overload of a feature.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
/// <param name="featureTextType">The write mode.</param>
/// <param name="isOverride">True if the feature is an override.</param>
/// <param name="nameString">The composed feature name.</param>
/// <param name="exportStatus">The feature export status.</param>
/// <param name="isConstructor">True if the feature is a constructor.</param>
/// <param name="isFirstFeature">True if the feature is the first in a list.</param>
/// <param name="isMultiline">True if there is a separating line above.</param>
public void WriteCSharp(ICSharpWriter writer, CSharpFeatureTextTypes featureTextType, bool isOverride, string nameString, CSharpExports exportStatus, bool isConstructor, ref bool isFirstFeature, ref bool isMultiline)
{
Debug.Assert(WriteDown);
IList <ICSharpParameter> SelectedParameterList = ParameterList;
IList <ICSharpParameter> SelectedResultList = ResultList;
if (isOverride && Precursor != null)
{
SelectedParameterList = Precursor.ParameterList;
SelectedResultList = Precursor.ResultList;
}
CSharpArgument.BuildParameterList(writer, SelectedParameterList, SelectedResultList, featureTextType, out string ArgumentEntityList, out string ArgumentNameList, out string ResultType);
string ExportStatusText;
if (featureTextType == CSharpFeatureTextTypes.Implementation)
{
bool IsHandled = false;
switch (Body)
{
case ICSharpDeferredBody AsDeferredBody:
CSharpAssertion.WriteContract(writer, AsDeferredBody.RequireList, AsDeferredBody.EnsureList, CSharpContractLocations.Other, true, ref isFirstFeature, ref isMultiline);
ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList});");
isMultiline = false;
IsHandled = true;
break;
case ICSharpEffectiveBody AsEffectiveBody:
CSharpAssertion.WriteContract(writer, AsEffectiveBody.RequireList, AsEffectiveBody.EnsureList, CSharpContractLocations.Other, true, ref isFirstFeature, ref isMultiline);
CSharpBodyFlags Flags = CSharpBodyFlags.MandatoryCurlyBrackets;
string ResultString = string.Empty;
List <string> InitialisationStringList = new List <string>();
if (ResultList.Count == 1)
{
Flags |= CSharpBodyFlags.HasResult;
ICSharpParameter Result = ResultList[0];
ResultString = Result.Feature.Type.Type2CSharpString(writer, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None);
}
else
{
if (ResultType != "void")
{
Flags |= CSharpBodyFlags.HasResult;
ResultString = ResultType;
}
foreach (ICSharpParameter Item in ResultList)
{
string InitValueString;
ICSharpType ResultEntityType = Item.Feature.Type;
if (ResultEntityType is ICSharpClassType AsClassType)
{
// TODO: when the type inherit from Enumeration
if (AsClassType.Class.Source.ClassGuid == LanguageClasses.AnyOptionalReference.Guid)
{
InitValueString = "new OptionalReference<>(null)"; // TODO
}
else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.String.Guid)
{
InitValueString = "\"\"";
}
else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Boolean.Guid)
{
InitValueString = "false";
}
else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Character.Guid)
{
InitValueString = "'\0'";
}
else if (AsClassType.Class.Source.ClassGuid == LanguageClasses.Number.Guid)
{
InitValueString = "0";
}
else
{
InitValueString = "null";
}
}
else
{
InitValueString = "null"; // TODO : tuples
}
string InitNameString = CSharpNames.ToCSharpIdentifier(Item.Name);
InitialisationStringList.Add($"{InitNameString} = {InitValueString};");
}
}
ExportStatusText = CSharpNames.ComposedExportStatus(isOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList})");
AsEffectiveBody.WriteCSharp(writer, Flags, ResultString, false, InitialisationStringList);
isMultiline = true;
IsHandled = true;
break;
case ICSharpPrecursorBody AsPrecursorBody:
if (isMultiline)
{
writer.WriteEmptyLine();
}
ExportStatusText = CSharpNames.ComposedExportStatus(true, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {ResultType} {nameString}({ArgumentEntityList})");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"return base.{nameString}({ArgumentNameList});");
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
isMultiline = true;
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
}
else
{
writer.WriteIndentedLine($"{ResultType} {nameString}({ArgumentEntityList});");
isMultiline = false;
}
}
private void WriteCSharpForcedReadWriteProperty(ICSharpWriter writer, bool isOverride, CSharpExports exportStatus, string propertyName, string resultType, ref bool isFirstFeature, ref bool isMultiline)
{
bool IsDeferred = false;
bool IsPrecursor = false;
isFirstFeature = false;
if (GetterBody != null)
{
if (GetterBody is ICSharpDeferredBody)
{
IsDeferred = true;
}
if (GetterBody is ICSharpPrecursorBody)
{
IsPrecursor = true;
}
}
if (SetterBody != null)
{
if (SetterBody is ICSharpDeferredBody)
{
IsDeferred = true;
}
if (SetterBody is ICSharpPrecursorBody)
{
IsPrecursor = true;
}
}
if (GetterBody != null || SetterBody != null)
{
if (IsDeferred)
{
bool IsGetterMultiline = isMultiline;
bool IsSetterMultiline = isMultiline;
if (GetterBody != null)
{
ICSharpDeferredBody DeferredGetterBody = GetterBody as ICSharpDeferredBody;
Debug.Assert(DeferredGetterBody != null);
CSharpAssertion.WriteContract(writer, DeferredGetterBody.RequireList, DeferredGetterBody.EnsureList, CSharpContractLocations.Getter, false, ref isFirstFeature, ref IsGetterMultiline);
IsSetterMultiline = false;
}
if (SetterBody != null)
{
ICSharpDeferredBody DeferredSetterBody = SetterBody as ICSharpDeferredBody;
Debug.Assert(DeferredSetterBody != null);
CSharpAssertion.WriteContract(writer, DeferredSetterBody.RequireList, DeferredSetterBody.EnsureList, CSharpContractLocations.Setter, false, ref isFirstFeature, ref IsSetterMultiline);
}
string ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName} {{ get; set; }}");
isMultiline = IsGetterMultiline || IsSetterMultiline;
}
else
{
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName}");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
if (IsPrecursor)
{
if (Source.PropertyKind != BaseNode.UtilityType.WriteOnly)
{
writer.WriteIndentedLine($"get {{ return base.{propertyName}; }}");
}
else
{
writer.WriteIndentedLine($"get {{ throw new InvalidOperationException(); }}");
}
if (Source.PropertyKind != BaseNode.UtilityType.ReadOnly)
{
writer.WriteIndentedLine($"set {{ base.{propertyName} = value; }}");
}
else
{
writer.WriteIndentedLine($"set {{ throw new InvalidOperationException(); }}");
}
}
else
{
if (GetterBody != null)
{
ICSharpEffectiveBody EffectiveGetterBody = GetterBody as ICSharpEffectiveBody;
Debug.Assert(EffectiveGetterBody != null);
isMultiline = false;
CSharpAssertion.WriteContract(writer, EffectiveGetterBody.RequireList, EffectiveGetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("get");
EffectiveGetterBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets | CSharpBodyFlags.HasResult, resultType, false, new List <string>());
}
else
{
writer.WriteIndentedLine($"get {{ throw new InvalidOperationException(); }}");
}
if (SetterBody != null)
{
ICSharpEffectiveBody EffectiveSetterBody = SetterBody as ICSharpEffectiveBody;
Debug.Assert(EffectiveSetterBody != null);
isMultiline = false;
CSharpAssertion.WriteContract(writer, EffectiveSetterBody.RequireList, EffectiveSetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("set");
EffectiveSetterBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets | CSharpBodyFlags.HasValue, string.Empty, false, new List <string>());
}
else
{
writer.WriteIndentedLine($"set {{ throw new InvalidOperationException(); }}");
}
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
isMultiline = true;
}
}
else
{
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName}");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
if (Source.PropertyKind != BaseNode.UtilityType.WriteOnly)
{
writer.WriteIndentedLine($"get {{ return _{propertyName}; }}");
}
else
{
writer.WriteIndentedLine($"get {{ throw new InvalidOperationException(); }}");
}
if (Source.PropertyKind != BaseNode.UtilityType.ReadOnly)
{
writer.WriteIndentedLine($"set {{ _{propertyName} = value; }}");
}
else
{
writer.WriteIndentedLine($"set {{ throw new InvalidOperationException(); }}");
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
isMultiline = true;
}
}
private void WriteCSharpWriteOnlyProperty(ICSharpWriter writer, bool isOverride, CSharpExports exportStatus, string propertyName, string resultType, ref bool isFirstFeature, ref bool isMultiline)
{
bool IsDeferred = false;
bool IsPrecursor = false;
isFirstFeature = false;
if (SetterBody != null)
{
if (SetterBody is ICSharpDeferredBody)
{
IsDeferred = true;
}
if (SetterBody is ICSharpPrecursorBody)
{
IsPrecursor = true;
}
}
if (SetterBody != null)
{
if (IsDeferred)
{
ICSharpDeferredBody DeferredSetterBody = SetterBody as ICSharpDeferredBody;
Debug.Assert(DeferredSetterBody != null);
CSharpAssertion.WriteContract(writer, DeferredSetterBody.RequireList, DeferredSetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
string ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName} {{ protected get; set; }}");
isMultiline = false;
}
else
{
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName}");
if (IsPrecursor)
{
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"set {{ base.{propertyName} = value; }}");
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
else
{
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"protected get {{ return _{propertyName}; }}");
ICSharpEffectiveBody EffectiveSetterBody = SetterBody as ICSharpEffectiveBody;
Debug.Assert(EffectiveSetterBody != null);
isMultiline = false;
CSharpAssertion.WriteContract(writer, EffectiveSetterBody.RequireList, EffectiveSetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("set");
EffectiveSetterBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets | CSharpBodyFlags.HasValue, string.Empty, false, new List <string>());
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
isMultiline = true;
}
}
else
{
if (isMultiline)
{
writer.WriteEmptyLine();
}
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {resultType} {propertyName} {{ protected get; set; }}");
isMultiline = false;
}
}
private void WriteCSharpImplementation(ICSharpWriter writer, CSharpExports exportStatus, bool isLocal, ref bool isFirstFeature, ref bool isMultiline)
{
writer.WriteDocumentation(Source);
string ResultType = EntityType.Type2CSharpString(writer, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None);
CSharpArgument.BuildParameterList(writer, IndexParameterList, out string ParameterEntityList, out string ParameterNameList);
string Accessors;
if (!IsForcedReadWrite && SetterBody == null)
{
Accessors = "{ get; }";
}
else if (!IsForcedReadWrite && GetterBody == null)
{
Accessors = "{ set; }";
}
else
{
Accessors = "{ get; set; }";
}
bool IsDeferred = false;
if (GetterBody != null)
{
if (GetterBody is ICSharpDeferredBody)
{
IsDeferred = true;
}
else
{
IsDeferred = false;
}
}
else if (SetterBody != null)
{
if (SetterBody is ICSharpDeferredBody)
{
IsDeferred = true;
}
else
{
IsDeferred = false;
}
}
if (IsDeferred)
{
if (GetterBody is ICSharpDeferredBody AsDeferredGetterBody)
{
CSharpAssertion.WriteContract(writer, AsDeferredGetterBody.RequireList, AsDeferredGetterBody.EnsureList, CSharpContractLocations.Getter, false, ref isFirstFeature, ref isMultiline);
isMultiline = false;
}
if (SetterBody is ICSharpDeferredBody AsDeferredSetterBody)
{
CSharpAssertion.WriteContract(writer, AsDeferredSetterBody.RequireList, AsDeferredSetterBody.EnsureList, CSharpContractLocations.Setter, false, ref isFirstFeature, ref isMultiline);
}
string ExportStatusText = CSharpNames.ComposedExportStatus(false, true, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {ResultType} this[{ParameterEntityList}] {Accessors}");
isMultiline = false;
}
else
{
string ExportStatusText = CSharpNames.ComposedExportStatus(IsOverride, false, false, exportStatus);
writer.WriteIndentedLine($"{ExportStatusText} {ResultType} this[{ParameterEntityList}]");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
bool IsPrecursor = false;
if (GetterBody != null)
{
if (GetterBody is ICSharpPrecursorBody)
{
IsPrecursor = true;
}
else
{
IsPrecursor = false;
}
}
else if (SetterBody != null)
{
if (GetterBody is ICSharpPrecursorBody)
{
IsPrecursor = true;
}
else
{
IsPrecursor = false;
}
}
if (IsPrecursor)
{
if (GetterBody is ICSharpPrecursorBody AsPrecursorGetterBody)
{
isMultiline = false;
CSharpAssertion.WriteContract(writer, AsPrecursorGetterBody.RequireList, AsPrecursorGetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("get");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"return base[{ParameterEntityList}];");
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
else if (IsForcedReadWrite)
{
writer.WriteIndentedLine("get { throw new InvalidOperationException(); }");
}
if (SetterBody is ICSharpPrecursorBody AsPrecursorSetterBody)
{
isMultiline = false;
CSharpAssertion.WriteContract(writer, AsPrecursorSetterBody.RequireList, AsPrecursorSetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("set");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
writer.WriteIndentedLine($"base[{ParameterEntityList}] = value;");
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
else if (IsForcedReadWrite)
{
writer.WriteIndentedLine("set { throw new InvalidOperationException(); }");
}
}
else
{
if (GetterBody != null)
{
if (GetterBody is ICSharpEffectiveBody AsEffectiveGetterBody)
{
isMultiline = false;
CSharpAssertion.WriteContract(writer, AsEffectiveGetterBody.RequireList, AsEffectiveGetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("get");
AsEffectiveGetterBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets | CSharpBodyFlags.HasResult, ResultType, false, new List <string>());
}
}
else if (IsForcedReadWrite)
{
writer.WriteIndentedLine("get { throw new InvalidOperationException(); }");
}
if (SetterBody != null)
{
if (SetterBody is ICSharpEffectiveBody AsEffectiveSetterBody)
{
isMultiline = false;
CSharpAssertion.WriteContract(writer, AsEffectiveSetterBody.RequireList, AsEffectiveSetterBody.EnsureList, CSharpContractLocations.Other, false, ref isFirstFeature, ref isMultiline);
writer.WriteIndentedLine("set");
AsEffectiveSetterBody.WriteCSharp(writer, CSharpBodyFlags.MandatoryCurlyBrackets | CSharpBodyFlags.HasValue, string.Empty, false, new List <string>());
}
}
else if (IsForcedReadWrite)
{
writer.WriteIndentedLine("set { throw new InvalidOperationException(); }");
}
}
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
isMultiline = true;
}
}