Session 2: constexpr ctors, virtual base, hoisting fixes, key constants

Parser:
- constexpr constructor detection in struct body (parseClassMember)
- virtual keyword preserved in base class declarations
- [this] lambda capture
- static_assert as TopLevelStatement (inside namespace)
- parseBaseClassEntry preserves virtual keyword in output

CodeGen/CppBuild:
- FunctionDecl.isConstexpr added to AstDecl
- constexpr functions emitted with constexpr keyword
- constexpr functions hoisted to namespace scope
- depResult.hoistedVariables emitted before class definitions
- static member definitions (Class::member) hoisted to namespace scope
- enum forward decls emitted before function forward decls
- ClassHoister: forward decl replaced by full definition uses definition position

PSketchInjector:
- Skip _PSketch injection for classes that inherit it transitively
- Prevents ambiguous base errors in diamond hierarchies

Processing.h:
- KEY_0-KEY_9 digit key constants
- SPACE key constant

Author: pepc84

mode/CppMode.jar

@@ -1489,6 +1489,9 @@ static constexpr int KEY_S=83; static constexpr int KEY_T=84;
 static constexpr int KEY_U=85; static constexpr int KEY_V=86;
 static constexpr int KEY_W=87; static constexpr int KEY_X=88;
 static constexpr int KEY_Y=89; static constexpr int KEY_Z=90;
+static constexpr int KEY_0=48; static constexpr int KEY_1=49; static constexpr int KEY_2=50; static constexpr int KEY_3=51; static constexpr int KEY_4=52;
+static constexpr int KEY_5=53; static constexpr int KEY_6=54; static constexpr int KEY_7=55; static constexpr int KEY_8=56; static constexpr int KEY_9=57;
+static constexpr int SPACE=32;
 
 static constexpr int PERIOD_KEY = 46;
 static constexpr int SLASH_KEY  = 47;

src/Processing.h

@@ -81,17 +81,26 @@ public static Result hoist(List<TopLevelItem> items) {
         }
 
         // Deduplicate: drop empty forward declarations when a full definition exists.
+        // When a forward decl is replaced by a full definition, use the full
+        // definition's position in the list (not the forward decl's position)
+        // so that class ordering matches source order of definitions.
         java.util.Map<String, TypeDef> best = new java.util.LinkedHashMap<>();
+        java.util.List<String> order = new java.util.ArrayList<>();
         for (TypeDef td : classBlocks) {
             String name = td.name();
             TypeDef existing = best.get(name);
             if (existing == null) {
                 best.put(name, td);
+                order.add(name);
             } else if (!td.members().isEmpty() && existing.members().isEmpty()) {
-                best.put(name, td); // full definition beats forward declaration
+                // Full definition replaces forward decl -- move to end to preserve source order
+                best.put(name, td);
+                order.remove(name);
+                order.add(name);
             }
         }
-        classBlocks = new ArrayList<>(best.values());
+        classBlocks = new ArrayList<>();
+        for (String n : order) classBlocks.add(best.get(n));
 
         boolean changed = true;
         for (int pass = 0; pass < classBlocks.size() * 2 && changed; pass++) {
@@ -502,13 +511,61 @@ public record Result(TypeDef typeDef, boolean injected) {
      *         never first) unless the class has no methods at all
      */
     public static List<Result> injectAll(List<TypeDef> hoistedClasses) {
+        // Build map of class name -> TypeDef for transitive base lookup
+        java.util.Map<String, TypeDef> byName = new java.util.LinkedHashMap<>();
+        for (TypeDef td : hoistedClasses) byName.put(td.name(), td);
+
+        // Determine which classes will get _PSketch injected
+        // A class should NOT get _PSketch if any of its bases already
+        // (transitively) gets _PSketch -- it will inherit it from them.
+        // This prevents ambiguous base errors in diamond hierarchies.
+        java.util.Set<String> willBeInjected = new java.util.LinkedHashSet<>();
+        for (TypeDef td : hoistedClasses) {
+            Result r = inject(td);
+            if (r.injected()) willBeInjected.add(td.name());
+        }
+
+        // For each class that would get _PSketch, check if any of its
+        // transitive bases also gets _PSketch. If so, skip injection
+        // since it inherits _PSketch already.
+        java.util.Set<String> skipInjection = new java.util.HashSet<>();
+        for (TypeDef td : hoistedClasses) {
+            if (!willBeInjected.contains(td.name())) continue;
+            // Check if any base (transitively) is also getting _PSketch
+            if (transitiveBasesGetPSketch(td, willBeInjected, byName)) {
+                skipInjection.add(td.name());
+            }
+        }
+
         List<Result> results = new ArrayList<>(hoistedClasses.size());
         for (TypeDef td : hoistedClasses) {
-            results.add(inject(td));
+            if (skipInjection.contains(td.name())) {
+                results.add(new Result(td, false)); // skip -- inherits via base
+            } else {
+                results.add(inject(td));
+            }
         }
         return results;
     }
 
+    /** True if any transitive base of td is in the willBeInjected set. */
+    private static boolean transitiveBasesGetPSketch(
+            TypeDef td,
+            java.util.Set<String> willBeInjected,
+            java.util.Map<String, TypeDef> byName) {
+        for (String base : td.baseClasses()) {
+            // Strip "virtual ", "public ", "protected ", "private " qualifiers
+            String baseName = base.replaceAll("\b(virtual|public|protected|private)\b\s*", "").trim();
+            // Strip template args if any
+            int lt = baseName.indexOf('<');
+            if (lt >= 0) baseName = baseName.substring(0, lt).trim();
+            if (willBeInjected.contains(baseName)) return true;
+            TypeDef baseTd = byName.get(baseName);
+            if (baseTd != null && transitiveBasesGetPSketch(baseTd, willBeInjected, byName)) return true;
+        }
+        return false;
+    }
+
     private static Result inject(TypeDef td) {
         if (!hasAnyMethod(td)) {
             return new Result(td, false);

src/java/AstPasses.java

@@ -1026,6 +1026,7 @@ private File writeSketchImpl(RunnerListener listener) throws IOException {
     warnReservedNames(code, listener);
     checkForUnsupportedJavaArraySyntax(code, listener);
     checkForArrayListGetValueCopy(code, listener);
+    checkForArrayListGetDotAccess(code, listener);
     code = stripRawStringLiterals(code);
     code = code.replaceAll("(?<=[0-9a-fA-FxXbB])'(?=[0-9a-fA-F])", "");
     code = javaToC(code);
@@ -1206,6 +1207,10 @@ private File writeSketchImpl(RunnerListener listener) throws IOException {
         } else if (item instanceof FunctionDecl fdce && fdce.isConstexpr()) {
           // constexpr functions must be at namespace scope for static_assert to use them
           autoHoisted.add(item);
+        } else if (item instanceof VariableDecl vdq && vdq.name().contains("::")) {
+          // Out-of-class static member definition: "int Agent::totalAgents = 0"
+          // must be at namespace scope, never inside struct Sketch
+          autoHoisted.add(item);
         } else {
           filteredRest.add(item);
         }
@@ -1240,6 +1245,13 @@ private File writeSketchImpl(RunnerListener listener) throws IOException {
       for (var e : enumResult.enums) out.append(CodeGen.generateNode(e, 0));
       for (FunctionDecl fd : forwardDecls) out.append(CodeGen.generateNode(fd, 0));
       for (var v : arrayResult.hoistedSizingConstants) out.append(CodeGen.generateNode(v, 0));
+      // Emit hoisted dependency variables BEFORE class definitions so
+      // hoisted classes can reference them (e.g. FloatList readings used by SensorBank).
+      java.util.Set<String> autoHoistedNames2 = new java.util.HashSet<>();
+      for (TopLevelItem av : autoHoisted) if (av instanceof VariableDecl avd2) autoHoistedNames2.add(avd2.name());
+      for (var v : depResult.hoistedVariables) {
+        if (!autoHoistedNames2.contains(v.name())) out.append(CodeGen.generateNode(v, 0));
+      }
       // Forward-declare every hoisted class before any definitions -- handles
       // cross-references between classes (e.g. Liquid::contains(Mover*) when
       // Liquid is emitted before Mover). Template classes can't be forward-declared
@@ -1258,12 +1270,7 @@ private File writeSketchImpl(RunnerListener listener) throws IOException {
       for (TopLevelItem alias : deferredAliases) out.append(CodeGen.generateNode(alias, 0));
       // Emit auto-hoisted variables at namespace scope
       for (TopLevelItem av : autoHoisted) out.append(CodeGen.generateNode(av, 0));
-      // Skip auto-hoisted variables from hoistedVariables to avoid redefinition
-      java.util.Set<String> autoHoistedNames = new java.util.HashSet<>();
-      for (TopLevelItem av : autoHoisted) if (av instanceof VariableDecl avd) autoHoistedNames.add(avd.name());
-      for (var v : depResult.hoistedVariables) {
-        if (!autoHoistedNames.contains(v.name())) out.append(CodeGen.generateNode(v, 0));
-      }
+      // hoistedVariables already emitted before class definitions above
       for (var v : arrayResult.hoistedArrays) out.append(CodeGen.generateNode(v, 0));
       for (FunctionDecl fd : depResult.hoistedFunctions) out.append(CodeGen.generateNode(fd, 0));
       // constexprScope (the NOT-PORTED half -- see EnumScopeExtractor's
@@ -2310,6 +2317,45 @@ private void checkForArrayListGetValueCopy(String code, RunnerListener listener)
       }
     }
   }
+  // [E0005b] Detect inline .get().field pattern: particles.get(0).x
+  // This is a pointer dereference error -- should use -> not .
+  private void checkForArrayListGetDotAccess(String code, RunnerListener listener) {
+    List<CppLexerToken> tokens;
+    try { tokens = new CppLexer(code).tokenize(); } catch (Exception e) { return; }
+    for (int i = 0; i + 6 < tokens.size(); i++) {
+      // Pattern: .get( ... ) . IDENTIFIER (not "(") -- member access on get() result
+      if (!tokens.get(i).isPunct(".")) continue;
+      if (!tokens.get(i + 1).text().equals("get")) continue;
+      if (!tokens.get(i + 2).isPunct("(")) continue;
+      // Consume the get(...) args
+      int j = i + 3; int depth = 1;
+      while (j < tokens.size() && depth > 0) {
+        if (tokens.get(j).isPunct("(")) depth++;
+        else if (tokens.get(j).isPunct(")")) depth--;
+        j++;
+      }
+      // After get(...), check if "." follows (not "->")
+      if (j < tokens.size() && tokens.get(j).isPunct(".")
+          && j + 1 < tokens.size()
+          && tokens.get(j + 1).type() == CppLexerTokenType.IDENTIFIER) {
+        int line = tokens.get(i).line();
+        String field = tokens.get(j + 1).text();
+        String url = getWebsiteBaseUrl() + "/error/E0005.html";
+        String msg =
+          "\n[E0005] .get() returns T* (pointer) -- use -> not . to access members.\n" +
+          "  Line " + line + ": \"...get(...)." + field + "\"\n" +
+          "  Fix: use -> instead of .:\n" +
+          "    list.get(i)->" + field + ";\n" +
+          "  Or store as pointer first:\n" +
+          "    Type* p = list.get(i);  p->" + field + ";\n" +
+          "  Reference: " + url + "\n";
+        System.err.println(msg);
+        listener.statusError("E0005: use -> not . after ArrayList.get() -- see console. " + url);
+        throw new AlreadyReportedException("E0005: .get().field -- see console.");
+      }
+    }
+  }
+
   private void checkForUnsupportedJavaArraySyntax(String code, RunnerListener listener) {
     try {
       CppJavaArrayCheck.check(code);

src/java/CppBuild.java

@@ -694,13 +694,13 @@ private TypeDef parseTypeDef(List<CppLexerToken> leadingComments, List<String> t
 
     /** "public BaseName" / "private BaseName" / "protected BaseName" / bare "BaseName". */
     private String parseBaseClassEntry() {
-        matchKeyword("virtual");
+        boolean isVirtualBase = matchKeyword("virtual");
         matchKeyword("public");
         if (!checkKeyword("public")) {
             matchKeyword("private");
             matchKeyword("protected");
         }
-        matchKeyword("virtual"); // virtual can appear before OR after access specifier
+        if (!isVirtualBase) isVirtualBase = matchKeyword("virtual");
         String name = parseQualifiedTypeName();
         // Consume template args on base class name: "Base<Derived>" (CRTP),
         // "std::enable_shared_from_this<T>", etc.
@@ -720,7 +720,7 @@ private String parseBaseClassEntry() {
             sb.append('>');
             name = sb.toString();
         }
-        return name;
+        return isVirtualBase ? "virtual " + name : name;
     }
 
     /**
@@ -2534,6 +2534,8 @@ private Capture parseCapture() {
             return new Capture("", true);
         }
         boolean byRef = matchOp("&");
+        // "this" is a keyword capture: [this] or [&this]
+        if (checkKeyword("this")) { advance(); return new Capture("this", byRef); }
         String name = expectIdentifier().text();
         // Init-capture: "z = z * 2" or "w = x + y" -- encode into name string
         if (checkOp("=")) {