Fix transpilation logic to exclude constant members and add expected output files for classes with constant members

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

@@ -34,9 +34,12 @@ public static (bool isEligible, ITypeDeclaration eligibleType) IsMemberEligibleF
                                     string coBuilder = "", bool warnMissingOrInconsistent = false)
     {
         var eligibility = field.IsEligibleForTranspile(sourceBuilder, warnMissingOrInconsistent);
-        var isEligible = ((field.AccessModifier == AccessModifier.Public || field.AccessModifier == AccessModifier.Protected || field.AccessModifier == AccessModifier.Internal)
-                            && eligibility.isEligibe 
-                            && !IsToBeOmitted(field, sourceBuilder, coBuilder));
+        var isEligible = ((field.AccessModifier == AccessModifier.Public || 
+                           field.AccessModifier == AccessModifier.Protected || 
+                           field.AccessModifier == AccessModifier.Internal)
+                           && !field.IsConstant
+                           && eligibility.isEligibe 
+                           && !IsToBeOmitted(field, sourceBuilder, coBuilder));
 
         return (isEligible, eligibility.eligibleType);
     }

src/AXSharp.compiler/tests/AXSharp.Compiler.CsTests/Cs/CsSourceBuilderTests.cs

@@ -283,6 +283,12 @@ public void abstract_members()
     }
 
 
+    [Fact]
+    public void class_with_constant_members()
+    {
+        CompareOutputs(GetMethodName());
+    }
+
     [Fact]
     public void generics()
     {

src/AXSharp.compiler/tests/AXSharp.Compiler.CsTests/samples/units/expected/ax/.g/Onliners/class_with_constant_members.g.cs

@@ -0,0 +1,225 @@
+using System;
+using AXSharp.Connector;
+using AXSharp.Connector.ValueTypes;
+using System.Collections.Generic;
+using AXSharp.Connector.Localizations;
+using AXSharp.Abstractions.Presentation;
+
+namespace ClassWithConstantMembersNamespace
+{
+    public partial class ClassWithConstantMembers : AXSharp.Connector.ITwinObject
+    {
+        public OnlinerInt myNonConstant { get; }
+
+        partial void PreConstruct(AXSharp.Connector.ITwinObject parent, string readableTail, string symbolTail);
+        partial void PostConstruct(AXSharp.Connector.ITwinObject parent, string readableTail, string symbolTail);
+        public ClassWithConstantMembers(AXSharp.Connector.ITwinObject parent, string readableTail, string symbolTail)
+        {
+            Symbol = AXSharp.Connector.Connector.CreateSymbol(parent.Symbol, symbolTail);
+            this.@SymbolTail = symbolTail;
+            this.@Connector = parent.GetConnector();
+            this.@Parent = parent;
+            HumanReadable = AXSharp.Connector.Connector.CreateHumanReadable(parent.HumanReadable, readableTail);
+            PreConstruct(parent, readableTail, symbolTail);
+            myNonConstant = @Connector.ConnectorAdapter.AdapterFactory.CreateINT(this, "myNonConstant", "myNonConstant");
+            parent.AddChild(this);
+            parent.AddKid(this);
+            PostConstruct(parent, readableTail, symbolTail);
+        }
+
+        public async virtual Task<T> OnlineToPlain<T>(eAccessPriority priority = eAccessPriority.Normal)
+        {
+            return await (dynamic)this.OnlineToPlainAsync(priority);
+        }
+
+        public async Task<global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers> OnlineToPlainAsync(eAccessPriority priority = eAccessPriority.Normal)
+        {
+            global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain = new global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers();
+            await this.ReadAsync<IgnoreOnPocoOperation>(priority);
+            plain.myNonConstant = myNonConstant.LastValue;
+            return plain;
+        }
+
+        [Obsolete("This method should not be used if you indent to access the controllers data. Use `OnlineToPlain` instead.")]
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+        public async Task<global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers> _OnlineToPlainNoacAsync()
+        {
+            global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain = new global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers();
+            plain.myNonConstant = myNonConstant.LastValue;
+            return plain;
+        }
+
+        [Obsolete("This method should not be used if you indent to access the controllers data. Use `OnlineToPlain` instead.")]
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+        protected async Task<global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers> _OnlineToPlainNoacAsync(global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain)
+        {
+            plain.myNonConstant = myNonConstant.LastValue;
+            return plain;
+        }
+
+        public async virtual Task PlainToOnline<T>(T plain, eAccessPriority priority = eAccessPriority.Normal)
+        {
+            await this.PlainToOnlineAsync((dynamic)plain, priority);
+        }
+
+        public async Task<IEnumerable<ITwinPrimitive>> PlainToOnlineAsync(global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain, eAccessPriority priority = eAccessPriority.Normal)
+        {
+#pragma warning disable CS0612
+            myNonConstant.LethargicWrite(plain.myNonConstant);
+#pragma warning restore CS0612
+            return await this.WriteAsync<IgnoreOnPocoOperation>(priority);
+        }
+
+        [Obsolete("This method should not be used if you indent to access the controllers data. Use `PlainToOnline` instead.")]
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+        public async Task _PlainToOnlineNoacAsync(global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain)
+        {
+#pragma warning disable CS0612
+            myNonConstant.LethargicWrite(plain.myNonConstant);
+#pragma warning restore CS0612
+        }
+
+        public async virtual Task<T> ShadowToPlain<T>()
+        {
+            return await (dynamic)this.ShadowToPlainAsync();
+        }
+
+        public async Task<global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers> ShadowToPlainAsync()
+        {
+            global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain = new global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers();
+            plain.myNonConstant = myNonConstant.Shadow;
+            return plain;
+        }
+
+        protected async Task<global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers> ShadowToPlainAsync(global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain)
+        {
+            plain.myNonConstant = myNonConstant.Shadow;
+            return plain;
+        }
+
+        public async virtual Task PlainToShadow<T>(T plain)
+        {
+            await this.PlainToShadowAsync((dynamic)plain);
+        }
+
+        public async Task<IEnumerable<ITwinPrimitive>> PlainToShadowAsync(global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain)
+        {
+            myNonConstant.Shadow = plain.myNonConstant;
+            return this.RetrievePrimitives();
+        }
+
+        ///<inheritdoc/>
+        public async virtual Task<bool> AnyChangeAsync<T>(T plain)
+        {
+            return await this.DetectsAnyChangeAsync((dynamic)plain);
+        }
+
+        ///<summary>
+        ///Compares if the current plain object has changed from the previous object.This method is used by the framework to determine if the object has changed and needs to be updated.
+        ///[!NOTE] Any member in the hierarchy that is ignored by the compilers (e.g. when CompilerOmitAttribute is used) will not be compared, and therefore will not be detected as changed.
+        ///</summary>
+        public async Task<bool> DetectsAnyChangeAsync(global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers plain, global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers latest = null)
+        {
+            if (latest == null)
+                latest = await this._OnlineToPlainNoacAsync();
+            var somethingChanged = false;
+            return await Task.Run(async () =>
+            {
+                if (plain.myNonConstant != myNonConstant.LastValue)
+                    somethingChanged = true;
+                plain = latest;
+                return somethingChanged;
+            });
+        }
+
+        public void Poll()
+        {
+            this.RetrievePrimitives().ToList().ForEach(x => x.Poll());
+        }
+
+        public global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers CreateEmptyPoco()
+        {
+            return new global::Pocos.ClassWithConstantMembersNamespace.ClassWithConstantMembers();
+        }
+
+        private IList<AXSharp.Connector.ITwinObject> Children { get; } = new List<AXSharp.Connector.ITwinObject>();
+
+        public IEnumerable<AXSharp.Connector.ITwinObject> GetChildren()
+        {
+            return Children;
+        }
+
+        private IList<AXSharp.Connector.ITwinElement> Kids { get; } = new List<AXSharp.Connector.ITwinElement>();
+
+        public IEnumerable<AXSharp.Connector.ITwinElement> GetKids()
+        {
+            return Kids;
+        }
+
+        private IList<AXSharp.Connector.ITwinPrimitive> ValueTags { get; } = new List<AXSharp.Connector.ITwinPrimitive>();
+
+        public IEnumerable<AXSharp.Connector.ITwinPrimitive> GetValueTags()
+        {
+            return ValueTags;
+        }
+
+        public void AddValueTag(AXSharp.Connector.ITwinPrimitive valueTag)
+        {
+            ValueTags.Add(valueTag);
+        }
+
+        public void AddKid(AXSharp.Connector.ITwinElement kid)
+        {
+            Kids.Add(kid);
+        }
+
+        public void AddChild(AXSharp.Connector.ITwinObject twinObject)
+        {
+            Children.Add(twinObject);
+        }
+
+        protected AXSharp.Connector.Connector @Connector { get; }
+
+        public AXSharp.Connector.Connector GetConnector()
+        {
+            return this.@Connector;
+        }
+
+        public string GetSymbolTail()
+        {
+            return this.SymbolTail;
+        }
+
+        public AXSharp.Connector.ITwinObject GetParent()
+        {
+            return this.@Parent;
+        }
+
+        public string Symbol { get; protected set; }
+
+        private string _attributeName;
+        public System.String AttributeName { get => string.IsNullOrEmpty(_attributeName) ? SymbolTail : _attributeName.Interpolate(this).CleanUpLocalizationTokens(); set => _attributeName = value; }
+
+        public System.String GetAttributeName(System.Globalization.CultureInfo culture)
+        {
+            if (string.IsNullOrEmpty(_attributeName))
+            {
+                return SymbolTail;
+            }
+
+            return this.Translate(_attributeName, culture).Interpolate(this);
+        }
+
+        private string _humanReadable;
+        public string HumanReadable { get => string.IsNullOrEmpty(_humanReadable) ? SymbolTail : _humanReadable.Interpolate(this).CleanUpLocalizationTokens(); set => _humanReadable = value; }
+
+        public System.String GetHumanReadable(System.Globalization.CultureInfo culture)
+        {
+            return this.Translate(_humanReadable, culture);
+        }
+
+        protected System.String @SymbolTail { get; set; }
+        protected AXSharp.Connector.ITwinObject @Parent { get; set; }
+        public AXSharp.Connector.Localizations.Translator Interpreter => global::units.PlcTranslator.Instance;
+    }
+}

src/AXSharp.compiler/tests/AXSharp.Compiler.CsTests/samples/units/expected/ax/.g/POCO/class_with_constant_members.g.cs

@@ -0,0 +1,18 @@
+using System;
+using AXSharp.Abstractions.Presentation;
+using AXSharp.Connector;
+
+namespace Pocos
+{
+    namespace ClassWithConstantMembersNamespace
+    {
+        public partial class ClassWithConstantMembers : AXSharp.Connector.IPlain
+        {
+            public ClassWithConstantMembers()
+            {
+            }
+
+            public Int16 myNonConstant { get; set; }
+        }
+    }
+}