Fix Class members processing and scope level resolve

nilproject · nilproject · commit 83ef0f8046ac · 2023-03-11T02:37:07.000+03:00
diff --git a/NiL.JS/Expressions/ClassDefinition.cs b/NiL.JS/Expressions/ClassDefinition.cs
@@ -32,8 +32,8 @@ public MemberDescriptor(Expression name, Expression value, bool @static)
         public override string ToString()
         {
             if (_static)
-                return "static " + _value;
-            return _value.ToString();
+                return "static " + _name + " = " + _value;
+            return _name + " = " + _value;
         }
     }
 
@@ -44,31 +44,32 @@ public sealed class ClassDefinition : EntityDefinition
     {
         private sealed class ClassConstructor : Function
         {
-            private readonly ClassDefinition classDefinition;
+            private readonly ClassDefinition _classDefinition;
             public override string name
             {
                 get
                 {
-                    return classDefinition.Name;
+                    return _classDefinition.Name;
                 }
             }
 
             public ClassConstructor(Context context, FunctionDefinition creator, ClassDefinition classDefinition)
                 : base(context, creator)
             {
-                this.classDefinition = classDefinition;
+                _classDefinition = classDefinition;
             }
 
             protected internal override JSValue ConstructObject()
             {
                 var result = CreateObject();
                 result.__proto__ = prototype._oValue as JSObject;
+                _classDefinition.setProperties(Context, result, false);
                 return result;
             }
 
             public override string ToString(bool headerOnly)
             {
-                return classDefinition.ToString();
+                return _classDefinition.ToString();
             }
         }
 
@@ -316,9 +317,7 @@ internal static CodeNode Parse(ParseInfo state, ref int index)
                         string fieldName = null;
                         if (state.Code[i] == '*')
                         {
-                            do
-                                i++;
-                            while (Tools.IsWhiteSpace(state.Code[i]));
+                            do i++; while (Tools.IsWhiteSpace(state.Code[i]));
                         }
 
                         if (Parser.ValidateName(state.Code, ref i, false, true, state.Strict))
@@ -352,7 +351,6 @@ internal static CodeNode Parse(ParseInfo state, ref int index)
                         }
                         else if (@static)
                         {
-                            fieldName = "static " + fieldName;
                             state.CodeContext |= CodeContext.InStaticMember;
                         }
 
@@ -365,18 +363,34 @@ internal static CodeNode Parse(ParseInfo state, ref int index)
                         if (async)
                             state.CodeContext |= CodeContext.InAsync;
 
-                        i = s;
-                        var method = FunctionDefinition.Parse(state, ref i, async ? FunctionKind.AsyncMethod : FunctionKind.Method) as FunctionDefinition;
-                        if (method == null)
-                            ExceptionHelper.ThrowSyntaxError("Unable to parse method", state.Code, i);
+                        while (Tools.IsWhiteSpace(state.Code[i])) i++;
+
+                        Expression expression = null;
+
+                        if (async || asterisk || fieldName == "constructor")
+                        {
+                            i = s;
+                            expression = FunctionDefinition.Parse(state, ref i, async ? FunctionKind.AsyncMethod : FunctionKind.Method) as FunctionDefinition;
+                            if (expression == null)
+                                ExceptionHelper.ThrowSyntaxError("Unable to parse method", state.Code, i);
+                        }
+                        else if (state.Code[i] == '=')
+                        {
+                            do i++; while (Tools.IsWhiteSpace(state.Code[i]));
+                            expression = ExpressionTree.Parse(state, ref i) as Expression;
+                        }
+                        else if (state.Code[i] == ';')
+                        {
+                            i++;
+                        }
 
                         if (fieldName == "constructor")
                         {
-                            ctor = method;
+                            ctor = expression as FunctionDefinition;
                         }
                         else
                         {
-                            flds[fieldName] = new MemberDescriptor(new Constant(method._name), method, @static);
+                            flds[fieldName] = new MemberDescriptor(new Constant(fieldName), expression, @static);
                         }
                     }
                 }
@@ -398,6 +412,7 @@ internal static CodeNode Parse(ParseInfo state, ref int index)
 
             var classDefinition = new ClassDefinition(name, baseType, new List<MemberDescriptor>(flds.Values).ToArray(), ctor, computedProperties.ToArray());
             classDefinition.reference.ScopeLevel = state.LexicalScopeLevel;
+            classDefinition.reference._descriptor.definitionScopeLevel = state.LexicalScopeLevel;
 
             if ((state.CodeContext & CodeContext.InExpression) == 0)
             {
@@ -497,39 +512,36 @@ public override JSValue Evaluate(Context context)
                     ctor.prototype.__proto__ = Tools.GetPropertyOrValue(baseProto.GetProperty("prototype"), baseProto)._oValue as JSObject;
                 }
 
-                ctor.__proto__ = baseProto as JSObject;
+                ctor.__proto__ = baseProto;
             }
 
+            setProperties(context, ctor, true);
+
+            variable?.Assign(ctor);
+
+            return ctor;
+        }
+
+        private void setProperties(Context context, JSObject target, bool @static)
+        {
             for (var i = 0; i < _members.Length; i++)
             {
                 var member = _members[i];
-                var value = member.Value.Evaluate(context);
-                JSValue target = null;
-                if (member.Static)
-                {
-                    target = ctor;
-                }
-                else
-                {
-                    target = ctor.prototype;
-                }
+                if (member.Static != @static)
+                    continue;
+
+                var value = member.Value?.Evaluate(context);
+                if (value is null)
+                    continue;
 
                 target.SetProperty(member.Name.Evaluate(null), value, true);
             }
 
             for (var i = 0; i < _computedProperties.Length; i++)
             {
                 var member = _computedProperties[i];
-
-                JSObject target = null;
-                if (member.Static)
-                {
-                    target = ctor;
-                }
-                else
-                {
-                    target = ctor.prototype._oValue as JSObject;
-                }
+                if (member.Static != @static)
+                    continue;
 
                 var key = member._name.Evaluate(context).CloneImpl(false);
                 var value = member._value.Evaluate(context).CloneImpl(false);
@@ -575,10 +587,6 @@ public override JSValue Evaluate(Context context)
                     }
                 }
             }
-
-            variable?.Assign(ctor);
-
-            return ctor;
         }
 
         public override T Visit<T>(Visitor<T> visitor)
@@ -657,7 +665,8 @@ public override void Optimize(ref CodeNode _this, FunctionDefinition owner, Inte
 
             for (var i = _members.Length; i-- > 0;)
             {
-                _members[i]._value.Optimize(ref _members[i]._value, owner, message, opts, stats);
+                if (_members[i]._value is not null)
+                    _members[i]._value.Optimize(ref _members[i]._value, owner, message, opts, stats);
             }
 
             for (var i = 0; i < _computedProperties.Length; i++)
@@ -681,7 +690,7 @@ public override void RebuildScope(FunctionInfo functionInfo, Dictionary<string,
             for (var i = 0; i < _members.Length; i++)
             {
                 _members[i].Name.RebuildScope(functionInfo, null, scopeBias);
-                _members[i].Value.RebuildScope(functionInfo, null, scopeBias);
+                _members[i].Value?.RebuildScope(functionInfo, null, scopeBias);
             }
         }
     }
diff --git a/Tests/Fuzz/ClassMembers.js b/Tests/Fuzz/ClassMembers.js
@@ -0,0 +1,34 @@
+﻿(function () {
+
+    function f() { };
+    var c = 1;
+    class Test {
+        d = 1;
+        m = 1;
+        static s = 2;
+        constructor() {
+            this.m = c++;
+        }
+    }
+
+    var t0 = new Test();
+    var t1 = new Test();
+
+    console.assert(Test.s == 2, "Error #" + 1);
+    console.assert(t0.s === undefined, "Error #" + 2);
+    console.assert(t1.s === undefined, "Error #" + 3);
+    console.assert(t0.s === undefined, "Error #" + 4);
+    console.assert(t0.__proto__.s === undefined, "Error #" + 5)
+
+    console.assert(Test.d === undefined, "Error #" + 6);
+    console.assert(t0.d === 1, "Error #" + 7);
+    console.assert(t1.d === 1, "Error #" + 8);
+    console.assert(t0.d === 1, "Error #" + 9);
+    console.assert(t0.__proto__.d === undefined, "Error #" + 10);
+
+    console.assert(Test.m === undefined, "Error #" + 11);
+    console.assert(t0.m === 1, "Error #" + 12);
+    console.assert(t1.m === 2, "Error #" + 13);
+    console.assert(t0.m === 1, "Error #" + 14);
+    console.assert(t0.__proto__.m === undefined, "Error #" + 15);
+})();

Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,8 @@ public MemberDescriptor(Expression name, Expression value, bool @static)`
`32`	`32`	`public override string ToString()`
`33`	`33`	`{`
`34`	`34`	`if (_static)`
`35`		`- return "static " + _value;`
`36`		`- return _value.ToString();`
	`35`	`+ return "static " + _name + " = " + _value;`
	`36`	`+ return _name + " = " + _value;`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`@@ -44,31 +44,32 @@ public sealed class ClassDefinition : EntityDefinition`
`44`	`44`	`{`
`45`	`45`	`private sealed class ClassConstructor : Function`
`46`	`46`	`{`
`47`		`- private readonly ClassDefinition classDefinition;`
	`47`	`+ private readonly ClassDefinition _classDefinition;`
`48`	`48`	`public override string name`
`49`	`49`	`{`
`50`	`50`	`get`
`51`	`51`	`{`
`52`		`- return classDefinition.Name;`
	`52`	`+ return _classDefinition.Name;`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`public ClassConstructor(Context context, FunctionDefinition creator, ClassDefinition classDefinition)`
`57`	`57`	`: base(context, creator)`
`58`	`58`	`{`
`59`		`- this.classDefinition = classDefinition;`
	`59`	`+ _classDefinition = classDefinition;`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`protected internal override JSValue ConstructObject()`
`63`	`63`	`{`
`64`	`64`	`var result = CreateObject();`
`65`	`65`	`result.__proto__ = prototype._oValue as JSObject;`
	`66`	`+ _classDefinition.setProperties(Context, result, false);`
`66`	`67`	`return result;`
`67`	`68`	`}`
`68`	`69`
`69`	`70`	`public override string ToString(bool headerOnly)`
`70`	`71`	`{`
`71`		`- return classDefinition.ToString();`
	`72`	`+ return _classDefinition.ToString();`
`72`	`73`	`}`
`73`	`74`	`}`
`74`	`75`
`@@ -316,9 +317,7 @@ internal static CodeNode Parse(ParseInfo state, ref int index)`
`316`	`317`	`string fieldName = null;`
`317`	`318`	`if (state.Code[i] == '*')`
`318`	`319`	`{`
`319`		`- do`
`320`		`- i++;`
`321`		`- while (Tools.IsWhiteSpace(state.Code[i]));`
	`320`	`+ do i++; while (Tools.IsWhiteSpace(state.Code[i]));`
`322`	`321`	`}`
`323`	`322`
`324`	`323`	`if (Parser.ValidateName(state.Code, ref i, false, true, state.Strict))`
`@@ -352,7 +351,6 @@ internal static CodeNode Parse(ParseInfo state, ref int index)`
`352`	`351`	`}`
`353`	`352`	`else if (@static)`
`354`	`353`	`{`
`355`		`- fieldName = "static " + fieldName;`
`356`	`354`	`state.CodeContext \|= CodeContext.InStaticMember;`
`357`	`355`	`}`
`358`	`356`
`@@ -365,18 +363,34 @@ internal static CodeNode Parse(ParseInfo state, ref int index)`
`365`	`363`	`if (async)`
`366`	`364`	`state.CodeContext \|= CodeContext.InAsync;`
`367`	`365`
`368`		`- i = s;`
`369`		`- var method = FunctionDefinition.Parse(state, ref i, async ? FunctionKind.AsyncMethod : FunctionKind.Method) as FunctionDefinition;`
`370`		`- if (method == null)`
`371`		`- ExceptionHelper.ThrowSyntaxError("Unable to parse method", state.Code, i);`
	`366`	`+ while (Tools.IsWhiteSpace(state.Code[i])) i++;`
	`367`	`+`
	`368`	`+ Expression expression = null;`
	`369`	`+`
	`370`	`+ if (async \|\| asterisk \|\| fieldName == "constructor")`
	`371`	`+ {`
	`372`	`+ i = s;`
	`373`	`+ expression = FunctionDefinition.Parse(state, ref i, async ? FunctionKind.AsyncMethod : FunctionKind.Method) as FunctionDefinition;`
	`374`	`+ if (expression == null)`
	`375`	`+ ExceptionHelper.ThrowSyntaxError("Unable to parse method", state.Code, i);`
	`376`	`+ }`
	`377`	`+ else if (state.Code[i] == '=')`
	`378`	`+ {`
	`379`	`+ do i++; while (Tools.IsWhiteSpace(state.Code[i]));`
	`380`	`+ expression = ExpressionTree.Parse(state, ref i) as Expression;`
	`381`	`+ }`
	`382`	`+ else if (state.Code[i] == ';')`
	`383`	`+ {`
	`384`	`+ i++;`
	`385`	`+ }`
`372`	`386`
`373`	`387`	`if (fieldName == "constructor")`
`374`	`388`	`{`
`375`		`- ctor = method;`
	`389`	`+ ctor = expression as FunctionDefinition;`
`376`	`390`	`}`
`377`	`391`	`else`
`378`	`392`	`{`
`379`		`- flds[fieldName] = new MemberDescriptor(new Constant(method._name), method, @static);`
	`393`	`+ flds[fieldName] = new MemberDescriptor(new Constant(fieldName), expression, @static);`
`380`	`394`	`}`
`381`	`395`	`}`
`382`	`396`	`}`
`@@ -398,6 +412,7 @@ internal static CodeNode Parse(ParseInfo state, ref int index)`
`398`	`412`
`399`	`413`	`var classDefinition = new ClassDefinition(name, baseType, new List<MemberDescriptor>(flds.Values).ToArray(), ctor, computedProperties.ToArray());`
`400`	`414`	`classDefinition.reference.ScopeLevel = state.LexicalScopeLevel;`
	`415`	`+ classDefinition.reference._descriptor.definitionScopeLevel = state.LexicalScopeLevel;`
`401`	`416`
`402`	`417`	`if ((state.CodeContext & CodeContext.InExpression) == 0)`
`403`	`418`	`{`
`@@ -497,39 +512,36 @@ public override JSValue Evaluate(Context context)`
`497`	`512`	`ctor.prototype.__proto__ = Tools.GetPropertyOrValue(baseProto.GetProperty("prototype"), baseProto)._oValue as JSObject;`
`498`	`513`	`}`
`499`	`514`
`500`		`- ctor.__proto__ = baseProto as JSObject;`
	`515`	`+ ctor.__proto__ = baseProto;`
`501`	`516`	`}`
`502`	`517`
	`518`	`+ setProperties(context, ctor, true);`
	`519`	`+`
	`520`	`+ variable?.Assign(ctor);`
	`521`	`+`
	`522`	`+ return ctor;`
	`523`	`+ }`
	`524`	`+`
	`525`	`+ private void setProperties(Context context, JSObject target, bool @static)`
	`526`	`+ {`
`503`	`527`	`for (var i = 0; i < _members.Length; i++)`
`504`	`528`	`{`
`505`	`529`	`var member = _members[i];`
`506`		`- var value = member.Value.Evaluate(context);`
`507`		`- JSValue target = null;`
`508`		`- if (member.Static)`
`509`		`- {`
`510`		`- target = ctor;`
`511`		`- }`
`512`		`- else`
`513`		`- {`
`514`		`- target = ctor.prototype;`
`515`		`- }`
	`530`	`+ if (member.Static != @static)`
	`531`	`+ continue;`
	`532`	`+`
	`533`	`+ var value = member.Value?.Evaluate(context);`
	`534`	`+ if (value is null)`
	`535`	`+ continue;`
`516`	`536`
`517`	`537`	`target.SetProperty(member.Name.Evaluate(null), value, true);`
`518`	`538`	`}`
`519`	`539`
`520`	`540`	`for (var i = 0; i < _computedProperties.Length; i++)`
`521`	`541`	`{`
`522`	`542`	`var member = _computedProperties[i];`
`523`		`-`
`524`		`- JSObject target = null;`
`525`		`- if (member.Static)`
`526`		`- {`
`527`		`- target = ctor;`
`528`		`- }`
`529`		`- else`
`530`		`- {`
`531`		`- target = ctor.prototype._oValue as JSObject;`
`532`		`- }`
	`543`	`+ if (member.Static != @static)`
	`544`	`+ continue;`
`533`	`545`
`534`	`546`	`var key = member._name.Evaluate(context).CloneImpl(false);`
`535`	`547`	`var value = member._value.Evaluate(context).CloneImpl(false);`
`@@ -575,10 +587,6 @@ public override JSValue Evaluate(Context context)`
`575`	`587`	`}`
`576`	`588`	`}`
`577`	`589`	`}`
`578`		`-`
`579`		`- variable?.Assign(ctor);`
`580`		`-`
`581`		`- return ctor;`
`582`	`590`	`}`
`583`	`591`
`584`	`592`	`public override T Visit<T>(Visitor<T> visitor)`
`@@ -657,7 +665,8 @@ public override void Optimize(ref CodeNode _this, FunctionDefinition owner, Inte`
`657`	`665`
`658`	`666`	`for (var i = _members.Length; i-- > 0;)`
`659`	`667`	`{`
`660`		`- _members[i]._value.Optimize(ref _members[i]._value, owner, message, opts, stats);`
	`668`	`+ if (_members[i]._value is not null)`
	`669`	`+ _members[i]._value.Optimize(ref _members[i]._value, owner, message, opts, stats);`
`661`	`670`	`}`
`662`	`671`
`663`	`672`	`for (var i = 0; i < _computedProperties.Length; i++)`
`@@ -681,7 +690,7 @@ public override void RebuildScope(FunctionInfo functionInfo, Dictionary<string,`
`681`	`690`	`for (var i = 0; i < _members.Length; i++)`
`682`	`691`	`{`
`683`	`692`	`_members[i].Name.RebuildScope(functionInfo, null, scopeBias);`
`684`		`- _members[i].Value.RebuildScope(functionInfo, null, scopeBias);`
	`693`	`+ _members[i].Value?.RebuildScope(functionInfo, null, scopeBias);`
`685`	`694`	`}`
`686`	`695`	`}`
`687`	`696`	`}`