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