Merge branch 'dev-mirage' of https://github.com/Inxton/axsharp into dev-mirage

Author: Brano5

README.md

@@ -20,7 +20,7 @@ This project is under development; however, we are [releasing versions](https://
 
 All versions released with a major version number `0` (e.g. 0.10.0) can have breaking changes to the previous version at any moment. Stable versions will be released with a major version number greater than `0` (e.g. 1.2.1).
 
-We plan to have production-ready libraries and tools in early spring 2024, that will cover:
+We plan to have production-ready libraries and tools in early spring 2026, that will cover:
 
 - compiler for building .NET twin object (ix compiler)
 - communication layer between .NET twin objects and S71500 series PLCs

src/AXSharp.compiler/src/AXSharp.Cs.Compiler/Helpers/SemanticsHelpers.cs

@@ -28,25 +28,30 @@ public static class SemanticsHelpers
     /// <param name="field">Field declaration</param>
     /// <param name="sourceBuilder">Source builder</param>
     /// <param name="coBuilder">Lateral builder signature</param>
+    /// <param name="warnMissingOrInconsistent">Issues warning when the type is eligible but not available.</param>
     /// <returns>True when the member is eligible for generation.</returns>
-    public static (bool isEligible, ITypeDeclaration eligibleType) IsMemberEligibleForTranspile(this IFieldDeclaration field, ISourceBuilder sourceBuilder, string coBuilder = "")
+    public static (bool isEligible, ITypeDeclaration eligibleType) IsMemberEligibleForTranspile(this IFieldDeclaration field, ISourceBuilder sourceBuilder, 
+                                    string coBuilder = "", bool warnMissingOrInconsistent = false)
     {
-        var eligibility = field.IsEligibleForTranspile(sourceBuilder);
+        var eligibility = field.IsEligibleForTranspile(sourceBuilder, warnMissingOrInconsistent);
         var isEligible = (field.AccessModifier == AccessModifier.Public
                             && eligibility.isEligibe
                             && !IsToBeOmitted(field, sourceBuilder, coBuilder));
 
         return (isEligible, eligibility.eligibleType);
     }
-    
+
 
     /// <summary>
     /// Finds type declaration.
     /// </summary>
     /// <param name="compilation">Compilation object</param>
     /// <param name="typeAccess">Required type</param>
+    /// <param name="warnMissingOrInconsistent">Will report missing type.</param>
     /// <returns>Required type if found.</returns>
-    public static ITypeDeclaration FindTypeDeclaration(this Compilation compilation, AX.ST.Semantic.Model.ISemanticTypeAccess? typeAccess)
+    public static ITypeDeclaration FindTypeDeclaration
+            (this Compilation compilation, AX.ST.Semantic.Model.ISemanticTypeAccess? typeAccess, 
+                bool warnMissingOrInconsistent = false)
     {
         if (typeAccess == null)
             return null;
@@ -82,14 +87,14 @@ public static ITypeDeclaration FindTypeDeclaration(this Compilation compilation,
             var span = typeAccess?.Location?.GetLineSpan();
             var line = span.Value.StartLinePosition.Line;
             var character = span.Value.StartLinePosition.Character;
-            if (candidates.Count() == 0)
+            if (candidates.Count() == 0 && warnMissingOrInconsistent)
             {
-                Log.Logger.Warning($"{span?.Filename}({line}:{character}) : Type '{typeAccess.TypeSymbol.Name}' not found the type may not be eligible for transpile or meta information is not available because this type is not defined in AX# compliant project. ");
+                Log.Logger.Warning($"{span?.Filename}({line}:{character}) : Type '{typeAccess.TypeSymbol.Name}' not found. The type may not be eligible for transpile or meta information is not available because this type is not defined in AX# compliant project.");
             }
 
-            if (candidates.Count() > 1)
+            if (candidates.Count() > 1 && warnMissingOrInconsistent)
             {
-                Log.Logger.Warning($"{span?.Filename}({line}:{character}) : Multiple types found for '{typeAccess.TypeSymbol.Name}' the declaration appears ambiguous. You may need to fully qualify the declaration.");
+                Log.Logger.Warning($"{span?.Filename}({line}:{character}) : Multiple types found for '{typeAccess.TypeSymbol.Name}'. The declaration appears ambiguous. You may need to fully qualify the declaration.");
             }
         }
         catch
@@ -101,7 +106,8 @@ public static ITypeDeclaration FindTypeDeclaration(this Compilation compilation,
         return null;
     }
 
-    public static ITypeDeclaration FindTypeDeclaration(this Compilation compilation, IDeclaration? typeAccess)
+    private static ITypeDeclaration FindTypeDeclaration(this Compilation compilation, IDeclaration? typeAccess, 
+        bool warnMissingOrInconsistent = false)
     {
         // This is to resolve fully qualified type name when the type cannot be determined propeprly form the semantic tree.
         // TODO: This workaround should be removed once we can properly use project dependencies in the stc.
@@ -123,20 +129,20 @@ public static ITypeDeclaration FindTypeDeclaration(this Compilation compilation,
             return candidates.First();
         }
 
-        if (candidates.Count() == 0)
+        if (candidates.Count() == 0 && warnMissingOrInconsistent)
         {
             Log.Logger.Warning($"Type '{typeAccess?.ToString()}' not found in the semantic tree. {typeAccess?.Location}");
         }
 
-        if (candidates.Count() > 1)
+        if (candidates.Count() > 1 && warnMissingOrInconsistent)
         {
             Log.Logger.Warning($"Multiple types found for '{typeAccess?.ToString()}' in the semantic tree. You may need to fully qualify the declaration.");
         }
 
         return null;
     }
 
-    public static string? DetermineFullyQualifiedName(this AX.ST.Semantic.Model.ISemanticTypeAccess declaration, Compilation compilation)
+    private static string? DetermineFullyQualifiedName(this AX.ST.Semantic.Model.ISemanticTypeAccess declaration, Compilation compilation)
     {
         return compilation.FindTypeDeclaration(declaration)?.FullyQualifiedName;
     }
@@ -184,7 +190,7 @@ public static void AddFullyQualifiedName(this IDeclaration declaration, Compilat
     /// <param name="declaration">Field declaration</param>
     /// <param name="compilation">Compilation object.</param>
     /// <returns>Fully qualified name of the declaration.</returns>
-    public static string? DetermineFullyQualifiedName(this IFieldDeclaration declaration, Compilation compilation)
+    private static string? DetermineFullyQualifiedName(this IFieldDeclaration declaration, Compilation compilation)
     {
         return compilation.FindTypeDeclaration(declaration.TypeAccess)?.FullyQualifiedName;
     }
@@ -195,7 +201,7 @@ public static void AddFullyQualifiedName(this IDeclaration declaration, Compilat
     /// <param name="declaration">Variable declaration</param>
     /// <param name="compilation">Compilation object.</param>
     /// <returns>Fully qualified name of the declaration.</returns>
-    public static string? DetermineFullyQualifiedName(this IVariableDeclaration declaration, Compilation compilation)
+    private static string? DetermineFullyQualifiedName(this IVariableDeclaration declaration, Compilation compilation)
     {
         return compilation.FindTypeDeclaration(declaration.TypeAccess)?.FullyQualifiedName;
     }
@@ -243,11 +249,12 @@ private static bool IsToBeOmitted(this IStorageDeclaration fieldDeclaration, ISo
     /// </summary>
     /// <param name="fieldDeclaration"></param>
     /// <param name="sourceBuilder"></param>
+    /// <param name="warnMissingOrInconsistent">Issues warning when the type is eligible but not available.</param>
     /// <returns>True when the type is eligible</returns>
-    public static (bool isEligibe, ITypeDeclaration eligibleType) IsEligibleForTranspile(this IFieldDeclaration fieldDeclaration, ISourceBuilder sourceBuilder)
+    private static (bool isEligibe, ITypeDeclaration eligibleType) IsEligibleForTranspile(this IFieldDeclaration fieldDeclaration, ISourceBuilder sourceBuilder, bool warnMissingOrInconsistent = false)
     {
         var type = fieldDeclaration.Type;
-        var fullyQualified = sourceBuilder.Compilation.FindTypeDeclaration(fieldDeclaration.TypeAccess);
+        var fullyQualified = sourceBuilder.Compilation.FindTypeDeclaration(fieldDeclaration.TypeAccess, warnMissingOrInconsistent);
         var isEligible = !(type is IReferenceTypeDeclaration)
                 &&
                 fieldDeclaration.IsAvailableForComm(sourceBuilder)
@@ -271,11 +278,13 @@ type is INamedValueTypeDeclaration ||
     /// </summary>
     /// <param name="variableDeclaration"></param>
     /// <param name="sourceBuilder"></param>
+    /// <param name="warnMissingOrInconsistent">Will issue warning when the type is eligible but not available.</param>
     /// <returns>True when the type is eligible</returns>
-    public static (bool isEligibe, ITypeDeclaration? eligibleType) IsEligibleForTranspile(this IVariableDeclaration variableDeclaration, ISourceBuilder sourceBuilder)
+    private static (bool isEligibe, ITypeDeclaration? eligibleType) IsEligibleForTranspile(this IVariableDeclaration variableDeclaration, 
+                        ISourceBuilder sourceBuilder, bool warnMissingOrInconsistent = false)
     {
         var type = variableDeclaration.Type;
-        var declaration = sourceBuilder.Compilation.FindTypeDeclaration(variableDeclaration.TypeAccess);
+        var declaration = sourceBuilder.Compilation.FindTypeDeclaration(variableDeclaration.TypeAccess, warnMissingOrInconsistent);
         var isEligible = !(type is IReferenceTypeDeclaration)
                &&
                variableDeclaration.IsAvailableForComm(sourceBuilder)
@@ -300,11 +309,14 @@ type is INamedValueTypeDeclaration ||
     /// </summary>
     /// <param name="arrayTypeDeclaration"></param>
     /// <param name="sourceBuilder">Source builder</param>
+    /// <param name="warnMissingOrInconsistent">Should issue warning if the type was not found though eligible.</param>
     /// <returns></returns>
-    public static (bool isEligibe, ITypeDeclaration? eligibleType) IsEligibleForTranspile(this IArrayTypeDeclaration arrayTypeDeclaration, ISourceBuilder sourceBuilder)
+    public static (bool isEligibe, ITypeDeclaration? eligibleType) IsEligibleForTranspile(this IArrayTypeDeclaration arrayTypeDeclaration, 
+            ISourceBuilder sourceBuilder, 
+            bool warnMissingOrInconsistent = false )
     {
         var singleDimensionalArray = arrayTypeDeclaration.Dimensions.Count == 1;
-        var declaration = sourceBuilder.Compilation.FindTypeDeclaration(arrayTypeDeclaration.ElementTypeAccess);
+        var declaration = sourceBuilder.Compilation.FindTypeDeclaration(arrayTypeDeclaration.ElementTypeAccess, warnMissingOrInconsistent);
         var isEligibleType = !(arrayTypeDeclaration.ElementTypeAccess.Type is IReferenceTypeDeclaration)
                              &&
                              arrayTypeDeclaration.IsAvailableForComm(sourceBuilder)
@@ -326,10 +338,12 @@ arrayTypeDeclaration.ElementTypeAccess.Type is INamedValueTypeDeclaration ||
     /// <param name="variable">Variable declaration</param>
     /// <param name="sourceBuilder">Source builder</param>
     /// <param name="coBuilder">Co-builder signature (e.g. POCO, Onliner, etc.)</param>
+    /// <param name="warnMissingOrInconsistent">Will issue warning when the type is eligible but not found</param>
     /// <returns>True when the member is eligible for generation.</returns>
-    public static (bool isEligibe, ITypeDeclaration? eligibleType) IsMemberEligibleForTranspile(this IVariableDeclaration variable, ISourceBuilder sourceBuilder, string coBuilder = "")
+    public static (bool isEligibe, ITypeDeclaration? eligibleType) IsMemberEligibleForTranspile(this IVariableDeclaration variable, 
+                                                    ISourceBuilder sourceBuilder, string coBuilder = "", bool warnMissingOrInconsistent = false)
     {
-        var eligibility = variable.IsEligibleForTranspile(sourceBuilder);
+        var eligibility = variable.IsEligibleForTranspile(sourceBuilder, warnMissingOrInconsistent);
         var eligible = variable.IsInGlobalMemory
                && eligibility.isEligibe
                && !IsToBeOmitted(variable, sourceBuilder, coBuilder);

src/AXSharp.compiler/src/AXSharp.Cs.Compiler/Onliner/CsOnlinerMemberBuilder.cs

@@ -32,7 +32,7 @@ protected CsOnlinerMemberBuilder(ISourceBuilder ISourceBuilder)
 
     public void CreateArrayTypeDeclaration(IArrayTypeDeclaration arrayTypeDeclaration, IxNodeVisitor visitor)
     {
-        var type = this.SourceBuilder.Compilation.FindTypeDeclaration(arrayTypeDeclaration.ElementTypeAccess);
+        var type = this.SourceBuilder.Compilation.FindTypeDeclaration(arrayTypeDeclaration.ElementTypeAccess, warnMissingOrInconsistent: true);
         //arrayTypeDeclaration.ElementTypeAccess.Type.Accept(visitor, this);
         type.Accept(visitor, this);
         AddToSource("[]");
@@ -51,7 +51,7 @@ public void CreateEnumTypeDeclaration(IEnumTypeDeclaration enumTypeDeclaration,
 
     public void CreateFieldDeclaration(IFieldDeclaration fieldDeclaration, IxNodeVisitor visitor)
     {
-        var eligibility = fieldDeclaration.IsMemberEligibleForTranspile(SourceBuilder);
+        var eligibility = fieldDeclaration.IsMemberEligibleForTranspile(SourceBuilder, warnMissingOrInconsistent: true);
         if (eligibility.isEligible)
         {
             AddToSource(fieldDeclaration.Pragmas.AddAttributes());
@@ -76,7 +76,7 @@ public void CreateFieldDeclaration(IFieldDeclaration fieldDeclaration, IxNodeVis
                     AddToSource("{get;}");
                     break;
                 case IArrayTypeDeclaration array:
-                    var arrayEligibility = array.IsEligibleForTranspile(SourceBuilder);
+                    var arrayEligibility = array.IsEligibleForTranspile(SourceBuilder, warnMissingOrInconsistent: true);
                     if (arrayEligibility.isEligibe)
                     {
                         AddToSource($"{fieldDeclaration.AccessModifier.Transform()} ");
@@ -145,7 +145,7 @@ public void CreateStructuredType(IStructuredTypeDeclaration structuredTypeDeclar
 
     public void CreateVariableDeclaration(IVariableDeclaration semantics, IxNodeVisitor visitor)
     {
-        var eligibility = semantics.IsMemberEligibleForTranspile(SourceBuilder);
+        var eligibility = semantics.IsMemberEligibleForTranspile(SourceBuilder, warnMissingOrInconsistent: true);
         if (eligibility.isEligibe)
         {
             AddToSource(semantics.Pragmas.AddAttributes());
@@ -170,7 +170,7 @@ public void CreateVariableDeclaration(IVariableDeclaration semantics, IxNodeVisi
                     AddToSource("{get;}");
                     break;
                 case IArrayTypeDeclaration array:
-                    var arrayEligible = array.IsEligibleForTranspile(SourceBuilder);
+                    var arrayEligible = array.IsEligibleForTranspile(SourceBuilder, warnMissingOrInconsistent: true);
                     if (arrayEligible.isEligibe)
                     {
                         AddToSource($"public");

src/AXSharp.compiler/src/AXSharp.Cs.Compiler/Onliner/CsOnlinerSourceBuilder.cs

@@ -160,7 +160,7 @@ public void CreateClassDeclaration(IClassDeclarationSyntax classDeclarationSynta
         AX.ST.Semantic.Model.ISemanticTypeAccess? extendedType = classDeclaration.ExtendedTypeAccesses.FirstOrDefault();
 
         //TODO: Workaround for not fully qualified declarations. To be addressed with proper dependency handling in stc.
-        var extend = Compilation.FindTypeDeclaration(extendedType);
+        var extend = Compilation.FindTypeDeclaration(extendedType, warnMissingOrInconsistent: true);
         if (extend != null)
         {
             AddToSource($"{extend.FullyQualifiedName}{ReplaceGenericSignature(classDeclaration)}");