/// <summary> /// Initializes a new instance of the <see cref="CSharpUnaryOperatorExpression"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly expression from which the C# expression is created.</param> protected CSharpUnaryOperatorExpression(ICSharpContext context, IUnaryOperatorExpression source) : base(context, source) { RightExpression = Create(context, (IExpression)source.RightExpression); Operator = context.GetFeature(source.SelectedFeature.Item) as ICSharpFunctionFeature; Debug.Assert(Operator != null); FeatureCall = new CSharpFeatureCall(context, new FeatureCall()); IResultType ResolvedRightResult = RightExpression.Source.ResolvedResult.Item; IExpressionType PreferredRightResult = ResolvedRightResult.Preferred; Debug.Assert(PreferredRightResult != null); if (PreferredRightResult.ValueType is IClassType AsClassType) { if (AsClassType.BaseClass.ClassGuid == LanguageClasses.Number.Guid) { IsCallingNumberFeature = true; } } if (IsCallingNumberFeature) { Debug.Assert(ResolvedRightResult.Count == 1); } Debug.Assert(Source.SelectedOverload.IsAssigned); IQueryOverload Overload = Source.SelectedOverload.Item; IQueryOverloadType ResolvedAssociatedType = Overload.ResolvedAssociatedType.Item; SelectedOverloadType = CSharpQueryOverloadType.Create(context, ResolvedAssociatedType, Operator.Owner); }
/// <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); }
/// <summary> /// Initializes a new instance of the <see cref="CSharpFunctionType"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly type from which the C# type is created.</param> /// <param name="originatingTypedef">The typedef where this type is declared.</param> protected CSharpFunctionType(ICSharpContext context, IFunctionType source, ICSharpTypedef originatingTypedef) : base(context, source, originatingTypedef) { Debug.Assert(source.OverloadList.Count > 0); ICSharpClass Owner = context.GetClass(source.EmbeddingClass); BaseType = Create(context, source.ResolvedBaseType.Item) as ICSharpTypeWithFeature; Debug.Assert(BaseType != null); foreach (IQueryOverloadType OverloadType in source.OverloadList) { ICSharpQueryOverloadType NewOverloadType = CSharpQueryOverloadType.Create(context, OverloadType, Owner); OverloadTypeList.Add(NewOverloadType); } }
/// <summary> /// Initializes a new instance of the <see cref="CSharpPrecursorExpression"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly expression from which the C# expression is created.</param> protected CSharpPrecursorExpression(ICSharpContext context, IPrecursorExpression source) : base(context, source) { PrecursorFeature = context.GetFeature(source.ResolvedPrecursor.Item.Feature) as ICSharpFeatureWithName; Debug.Assert(PrecursorFeature != null); ParentFeature = context.GetFeature((ICompiledFeature)source.EmbeddingFeature) as ICSharpFeatureWithName; Debug.Assert(ParentFeature != null); FeatureCall = new CSharpFeatureCall(context, source.FeatureCall.Item); if (Source.SelectedOverloadType.IsAssigned) { SelectedOverloadType = CSharpQueryOverloadType.Create(context, Source.SelectedOverloadType.Item, PrecursorFeature.Owner); } else { SelectedOverloadType = null; } }
/// <summary> /// Initializes a new instance of the <see cref="CSharpBinaryOperatorExpression"/> class. /// </summary> /// <param name="source">The Easly expression from which the C# expression is created.</param> /// <param name="context">The creation context.</param> protected CSharpBinaryOperatorExpression(ICSharpContext context, IBinaryOperatorExpression source) : base(context, source) { LeftExpression = Create(context, (IExpression)source.LeftExpression); RightExpression = Create(context, (IExpression)source.RightExpression); Operator = context.GetFeature(source.SelectedFeature.Item) as ICSharpFunctionFeature; Debug.Assert(Operator != null); IResultType ResolvedLeftResult = LeftExpression.Source.ResolvedResult.Item; IExpressionType PreferredLeftResult = ResolvedLeftResult.Preferred; Debug.Assert(PreferredLeftResult != null); if (PreferredLeftResult.ValueType is IClassType AsClassType) { if (AsClassType.BaseClass.ClassGuid == LanguageClasses.Number.Guid || AsClassType.BaseClass.ClassGuid == LanguageClasses.Integer.Guid) { IsCallingNumberFeature = true; } } if (IsCallingNumberFeature) { IResultType ResolvedRightResult = RightExpression.Source.ResolvedResult.Item; Debug.Assert(ResolvedRightResult.Count == 1); } else { if (!LeftExpression.IsSingleResult) { IResultType LeftResultType = LeftExpression.Source.ResolvedResult.Item; LeftNameList = new List <string>(); LeftResultNameIndex = LeftResultType.ResultNameIndex; for (int i = 0; i < LeftResultType.Count; i++) { IExpressionType DestinationType = LeftResultType.At(i); string Text = DestinationType.Name; LeftNameList.Add(Text); } } if (!RightExpression.IsSingleResult) { IResultType RightResultType = RightExpression.Source.ResolvedResult.Item; RightNameList = new List <string>(); RightResultNameIndex = RightResultType.ResultNameIndex; for (int i = 0; i < RightResultType.Count; i++) { IExpressionType DestinationType = RightResultType.At(i); string Text = DestinationType.Name; RightNameList.Add(Text); } } } FeatureCall = new CSharpFeatureCall(context, Source.FeatureCall.Item); Debug.Assert(Source.SelectedOverload.IsAssigned); IQueryOverload Overload = Source.SelectedOverload.Item; IQueryOverloadType ResolvedAssociatedType = Overload.ResolvedAssociatedType.Item; SelectedOverloadType = CSharpQueryOverloadType.Create(context, ResolvedAssociatedType, Operator.Owner); }