fix: new WorkflowScript("filename") special case and CGS023 parameter count validation (#110)

Author: davhdavh

Catglobe.CgScript.EditorSupport.Lsp.Tests/SemanticAnalyzerDiagnosticsTests.cs

@@ -528,14 +528,14 @@ public void Constructor_WrongArgType_ReportsCGS023()
    }
 
    [Fact]
-   public void Constructor_NoArgs_NoCGS023()
+   public void Constructor_NoArgs_ReportsCGS023()
    {
-      // new String() — zero args is valid (all params treated as optional)
+      // new String() — constructor requires a string arg; zero args is a mismatch
       var diags = AnalyzeWithObjects(
          "string s = new String();",
          new Dictionary<string, ObjectDefinition> { ["String"] = MakeStringDef() });
 
-      Assert.DoesNotContain(diags, d => d.Code == "CGS023");
+      Assert.Contains(diags, d => d.Code == "CGS023" && d.Message.Contains("String"));
    }
 
    [Fact]
@@ -569,6 +569,39 @@ public void KnownObjectsFromLoader_InvalidConstructorArgs_ReportsCGS023()
       Assert.Contains(diags, d => d.Code == "CGS023" && d.Message.Contains("String"));
    }
 
+   [Fact]
+   public void WorkflowScript_FilenameOverload_NoCGS023()
+   {
+      // new WorkflowScript("filename") is a preprocessor special form that the source generator
+      // replaces with new WorkflowScript(resourceId) on deployment.  No CGS023 should be raised.
+      // WithPreprocessorExtensions() must be called — this overload is NOT in the base definitions.
+      var result = CgScriptParseService.Parse("WorkflowScript script = new WorkflowScript(\"myScript.cgs\");");
+      var diags = SemanticAnalyzer.Analyze(result.Tree, new CgScriptDefinitions().WithPreprocessorExtensions());
+
+      Assert.DoesNotContain(diags, d => d.Code == "CGS023");
+   }
+
+   [Fact]
+   public void WorkflowScript_FilenameOverload_NotInjectedInBaseDefinitions()
+   {
+      // Without WithPreprocessorExtensions(), new WorkflowScript("filename") should report CGS023
+      // because the base definitions only know about the real API constructors.
+      var result = CgScriptParseService.Parse("WorkflowScript script = new WorkflowScript(\"myScript.cgs\");");
+      var diags = SemanticAnalyzer.Analyze(result.Tree, new CgScriptDefinitions());
+
+      Assert.Contains(diags, d => d.Code == "CGS023");
+   }
+
+   [Fact]
+   public void WorkflowScript_TooManyStringArgs_ReportsCGS023()
+   {
+      // new WorkflowScript("a", "b", "c") — no constructor accepts three strings even with preprocessor extensions
+      var result = CgScriptParseService.Parse("WorkflowScript script = new WorkflowScript(\"a\", \"b\", \"c\");");
+      var diags = SemanticAnalyzer.Analyze(result.Tree, new CgScriptDefinitions().WithPreprocessorExtensions());
+
+      Assert.Contains(diags, d => d.Code == "CGS023" && d.Message.Contains("WorkflowScript"));
+   }
+
    // ── CGS024: method call argument mismatch ─────────────────────────────────
 
    private static ObjectDefinition MakeStringWithCompareDef()
@@ -873,4 +906,25 @@ public void StringBuilderAppendFormat_WithMultipleArgs_NoCGS024()
 
       Assert.DoesNotContain(diags, d => d.Code == "CGS024");
    }
+
+   [Fact]
+   public void FormatFunction_WithMultipleArgs_NoCGS024()
+   {
+      // format("{0} {1}", a, b) — format accepts "Params object" so any number of args is valid.
+      var result = CgScriptParseService.Parse("string s = format(\"{0} {1}\", 1, 2);");
+      var diags  = SemanticAnalyzer.Analyze(result.Tree, new CgScriptDefinitions());
+
+      Assert.DoesNotContain(diags, d => d.Code == "CGS024");
+   }
+
+   [Fact]
+   public void WorkflowScriptInvoke_WithArrayArg_NoCGS024()
+   {
+      // WorkflowScript.Invoke(array) — exactly one array argument is valid.
+      // WithPreprocessorExtensions() is needed because new WorkflowScript("filename") is the preprocessor form.
+      var result = CgScriptParseService.Parse("WorkflowScript ws = new WorkflowScript(\"test.cgs\"); array args = new array(); ws.Invoke(args);");
+      var diags  = SemanticAnalyzer.Analyze(result.Tree, new CgScriptDefinitions().WithPreprocessorExtensions());
+
+      Assert.DoesNotContain(diags, d => d.Code == "CGS024");
+   }
 }

Catglobe.CgScript.EditorSupport.Lsp/CgScriptDefinitionsFactory.cs

@@ -32,7 +32,7 @@ public static async Task<CgScriptDefinitions> CreateFromUrlAsync(string siteUrl,
          CgScriptDefinitions.TraceSource.TraceInformation(
             "Loaded definitions from {0}: {1} functions, {2} objects, {3} constants",
             url, result.Functions.Count, result.Objects.Count, result.Constants.Count);
-         return result;
+         return result.WithPreprocessorExtensions();
       }
       catch (JsonException ex) when (ex is not null)
       {
@@ -46,7 +46,7 @@ public static async Task<CgScriptDefinitions> CreateFromUrlAsync(string siteUrl,
       {
          CgScriptDefinitions.TraceSource.TraceEvent(TraceEventType.Warning, 0,
             "Failed to fetch definitions from {0} — falling back to bundled definitions: {1}", url, ex.Message);
-         return new CgScriptDefinitions();
+         return new CgScriptDefinitions().WithPreprocessorExtensions();
       }
    }
 }

Catglobe.CgScript.EditorSupport.Parsing/CgScriptDefinitions.cs

@@ -428,6 +428,27 @@ public CgScriptDefinitions WithExtraGlobalVariables(IReadOnlyDictionary<string,
          Enums     is Dictionary<string, EnumDefinition>     ed ? ed : Enums.ToDictionary(kv => kv.Key, kv => kv.Value, StringComparer.OrdinalIgnoreCase));
    }
 
+   /// <summary>
+   /// Returns a new <see cref="CgScriptDefinitions"/> with extra constructor overloads that are
+   /// only valid when editing CgScript files processed by the source generator or deployed through
+   /// VS / VS Code (e.g., <c>new WorkflowScript("filename.cgs")</c> which the source generator
+   /// rewrites to <c>new WorkflowScript(resourceId)</c>).
+   /// Do NOT call this from the web runtime context where definitions come from a live server.
+   /// </summary>
+   public CgScriptDefinitions WithPreprocessorExtensions()
+   {
+      if (!ObjectMemberInfos.TryGetValue("WorkflowScript", out var wsMemberInfo)) return this;
+      var modified = ObjectMemberInfos.ToDictionary(kv => kv.Key, kv => kv.Value, StringComparer.Ordinal);
+      modified["WorkflowScript"] = wsMemberInfo.WithExtraConstructorOverload(new[] { "string" });
+      return new CgScriptDefinitions(
+         Functions is Dictionary<string, FunctionDefinition> fd ? fd : Functions.ToDictionary(kv => kv.Key, kv => kv.Value, StringComparer.OrdinalIgnoreCase),
+         Objects   is Dictionary<string, ObjectDefinition>   od ? od : Objects.ToDictionary(kv => kv.Key, kv => kv.Value, StringComparer.OrdinalIgnoreCase),
+         Constants,
+         GlobalVariables,
+         Enums     is Dictionary<string, EnumDefinition>     ed ? ed : Enums.ToDictionary(kv => kv.Key, kv => kv.Value, StringComparer.OrdinalIgnoreCase))
+      { ObjectMemberInfos = modified };
+   }
+
    /// <summary>
    /// Creates a <see cref="CgScriptDefinitions"/> by deserializing JSON from <paramref name="stream"/>.
    /// Used by the Lsp layer to load definitions fetched over HTTP.

Catglobe.CgScript.EditorSupport.Parsing/ObjectMemberInfo.cs

@@ -71,4 +71,16 @@ public ObjectMemberInfo(
 
    /// <summary>Returns <c>true</c> when the type exposes a method with the given name.</summary>
    public bool HasMethod(string name) => _methodNames.Contains(name);
+
+   /// <summary>
+   /// Returns a new <see cref="ObjectMemberInfo"/> identical to this one but with
+   /// <paramref name="paramTypes"/> added as an additional constructor overload.
+   /// </summary>
+   internal ObjectMemberInfo WithExtraConstructorOverload(IReadOnlyList<string> paramTypes)
+   {
+      var ctors = ConstructorOverloads is null
+         ? new List<IReadOnlyList<string>> { paramTypes }
+         : new List<IReadOnlyList<string>>(ConstructorOverloads) { paramTypes };
+      return new ObjectMemberInfo(Properties, _methodNames, PropertyReturnTypes, ctors, MethodOverloads, ObsoletePropertyNames, ObsoleteMethodNames);
+   }
 }

Catglobe.CgScript.EditorSupport.Parsing/SemanticAnalyzer.cs

@@ -1205,8 +1205,7 @@ private static bool IsCallValid(FunctionInfo funcInfo, string?[] argTypes)
 
    /// <summary>
    /// Returns <c>true</c> when at least one overload accepts the given argument types.
-   /// All parameters are treated as optional: a call with fewer args than an overload's
-   /// parameter count is valid as long as each supplied arg type matches.
+   /// The argument count must exactly match the overload's parameter count.
    /// An overload whose last parameter type is <c>"Params object"</c> is variadic and
    /// accepts any number of arguments beyond the preceding fixed parameters.
    /// </summary>
@@ -1236,7 +1235,7 @@ private static bool IsAnyOverloadValid(
             continue;
          }
 
-         if (argTypes.Length > overload.Count) continue; // too many args for this overload
+         if (argTypes.Length != overload.Count) continue;
          if (AllArgsCompatible(overload, argTypes)) return true;
       }
       return false;

Catglobe.CgScript.EditorSupport.SourceGenerator/CgScriptWrapperGenerator.cs

@@ -290,7 +290,7 @@ private static string SanitizeHintName(string name)
       return sb.ToString();
    }
 
-   private static readonly CgScriptDefinitions _definitions = new();
+   private static readonly CgScriptDefinitions _definitions = new CgScriptDefinitions().WithPreprocessorExtensions();
 
    private static void ReportSemanticDiagnostics(
       SourceProductionContext spc,