/// <summary> /// Initializes a new instance of the <see cref="CSharpType"/> 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 CSharpType(ICSharpContext context, ICompiledType source, ICSharpTypedef originatingTypedef) { Debug.Assert(source != null); Debug.Assert(originatingTypedef != null); Source = source; OriginatingTypedef = originatingTypedef; }
/// <summary> /// Initializes a new instance of the <see cref="CSharpProcedureType"/> 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 CSharpProcedureType(ICSharpContext context, IProcedureType 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 (ICommandOverloadType OverloadType in source.OverloadList) { ICSharpCommandOverloadType NewOverloadType = CSharpCommandOverloadType.Create(context, OverloadType, Owner); OverloadTypeList.Add(NewOverloadType); } }
/// <summary> /// Create a new C# type. /// </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> public static ICSharpProcedureType Create(ICSharpContext context, IProcedureType source, ICSharpTypedef originatingTypedef) { return(new CSharpProcedureType(context, source, originatingTypedef)); }
/// <summary> /// Creates a new C# type associated to a typedef. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly type from which the C# type is created.</param> /// <param name="typedef">The typedef.</param> public static ICSharpType Create(ICSharpContext context, ICompiledType source, ICSharpTypedef typedef) { ICSharpType Result = null; switch (source) { case IClassType AsClassType: Result = CSharpClassType.Create(context, AsClassType); break; case IFormalGenericType AsFormalGenericType: Result = CSharpFormalGenericType.Create(context, AsFormalGenericType); break; case IFunctionType AsFunctionType: Result = CSharpFunctionType.Create(context, AsFunctionType, typedef); break; case IProcedureType AsProcedureType: Result = CSharpProcedureType.Create(context, AsProcedureType, typedef); break; case IIndexerType AsIndexerType: Result = CSharpIndexerType.Create(context, AsIndexerType); break; case IPropertyType AsPropertyType: Result = CSharpPropertyType.Create(context, AsPropertyType); break; case ITupleType AsTupleType: Result = CSharpTupleType.Create(context, AsTupleType); break; } Debug.Assert(Result != null); return(Result); }
/// <summary> /// Create a new C# type. /// </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> public static ICSharpFunctionType Create(ICSharpContext context, IFunctionType source, ICSharpTypedef originatingTypedef) { return(new CSharpFunctionType(context, source, originatingTypedef)); }