ST6-ST13: parser fixes, constexpr tracking, ArrayList semantics, E0005

Parser fixes:
- Member pointer params: int Widget::* dp, int (Widget::*mp)(int) const
- Ref-to-array params: int (&arr)[10], int (*arr)[10]
- ->* operator as single token
- Template non-type params: int T::* Field, int (T::*Method)(int) const
- &Widget::value as template arg (non-type template arg)
- sizeof in parsePrimary with full expression preservation
- Wide string literals: L"...", u"...", U"...", u8"..."
- Adjacent string literal concatenation
- enum underlying type: enum class Color : int
- enum value initializers: Red = 1, Green = 2
- if constexpr
- for-loop multi-decl init: for (int i=0, j=10; ...)
- for-loop comma update: i++, j--
- volatile qualifier in all contexts
- Variable templates: pi<float>
- template<typename T> using Alias = ... (template aliases)
- static_assert passthrough
- constexpr constructor detection in struct body
- parsePrimary: sizeof renders actual content

CodeGen fixes:
- FunctionDecl.isConstexpr field added to AstDecl
- constexpr functions emitted with constexpr keyword
- constexpr functions hoisted to namespace scope
- new Foo() in value context strips new (emitDeclaratorTail)
- emitForStmt: Block init for multi-decl for-loop
- emitParamList: ref-to-array and member fn ptr param decoding
- decltype(expr) preserved verbatim (not converted to auto)
- using X = ... type aliases deferred after struct definitions
- static_assert emitted as TopLevelStatement (inside namespace)
- enum forward decls emitted before function forward decls

CppBuild fixes:
- constexpr functions hoisted to namespace scope
- auto/std::function variables hoisted to namespace scope
- diamond operator expansion: new ArrayList<>() -> ArrayList<T>()
- E0005: ArrayList.get() value-copy detection with website URL
- getWebsiteBaseUrl() reads from config/cppmode.properties
- expandDiamondOperator() in javaToC

Processing.h fixes:
- #include <climits> for INT_MAX/INT_MIN
- color template constructors for mixed int/float args
- ArrayList<T,true> add(T v) by-value overload
- ArrayList<T,true> get() returns T* (pointer semantics)

Author: pepc84

config/cppmode.properties

@@ -1,5 +1,3 @@
-mkdir -p ~/sketchbook/modes/CppMode/config
-cat > ~/sketchbook/modes/CppMode/config/cppmode.properties << 'EOF'
 # Single source of truth for CppMode-wide settings. Both CppBuild.java
 # and scripts/rebuild-engine.sh read this file directly, so changing
 # either value here updates behavior everywhere at once instead of

mode/CppMode.jar

@@ -58,10 +58,17 @@ record VariableDecl(
     Expr initializer,
     boolean isConst,
     boolean isStatic,
+    List<String> templateParams,
     int line,
     int col,
     List<CppLexerToken> leadingComments
 ) implements TopLevelItem {
+    VariableDecl(TypeRef type, String name, List<Expr> arrayDims,
+            Expr initializer, boolean isConst, boolean isStatic,
+            int line, int col, List<CppLexerToken> leadingComments) {
+        this(type, name, arrayDims, initializer, isConst, isStatic,
+             List.of(), line, col, leadingComments);
+    }
 }
 
 
@@ -109,6 +116,7 @@ record FunctionDecl(
     boolean isVirtual,
     boolean isOverride,
     boolean isConst,
+    boolean isConstexpr,
     boolean isStatic,
     boolean isPureVirtual,      // "= 0" specifier -- distinct from body==null (an ordinary forward
                                  // declaration also has a null body but should NOT render "= 0")

src/Processing.h

@@ -80,6 +80,19 @@ public static Result hoist(List<TopLevelItem> items) {
             }
         }
 
+        // Deduplicate: drop empty forward declarations when a full definition exists.
+        java.util.Map<String, TypeDef> best = new java.util.LinkedHashMap<>();
+        for (TypeDef td : classBlocks) {
+            String name = td.name();
+            TypeDef existing = best.get(name);
+            if (existing == null) {
+                best.put(name, td);
+            } else if (!td.members().isEmpty() && existing.members().isEmpty()) {
+                best.put(name, td); // full definition beats forward declaration
+            }
+        }
+        classBlocks = new ArrayList<>(best.values());
+
         boolean changed = true;
         for (int pass = 0; pass < classBlocks.size() * 2 && changed; pass++) {
             changed = false;
@@ -293,6 +306,35 @@ public static boolean containsCall(Node root, String name) {
         return new Finder(name, true).visit(root);
     }
 
+    public static boolean containsBareFunctionCall(Node root) {
+        return new BareFunctionCallFinder().visit(root);
+    }
+
+    private static final class BareFunctionCallFinder {
+        boolean visit(Node n) {
+            if (n == null) return false;
+            if (n instanceof CallExpr c) {
+                if (c.callee() instanceof Identifier) return true;
+                for (var arg : c.args()) if (visit(arg)) return true;
+                return visit(c.callee());
+            }
+            if (n instanceof Block b) { for (var s : b.statements()) if (visit(s)) return true; }
+            if (n instanceof ExprStatement es) return visit(es.expr());
+            if (n instanceof ReturnStatement rs) return visit(rs.value());
+            if (n instanceof IfStatement ifs) return visit(ifs.condition()) || visit(ifs.thenBranch()) || visit(ifs.elseBranch());
+            if (n instanceof WhileStatement ws) return visit(ws.condition()) || visit(ws.body());
+            if (n instanceof ForStatement fs) return visit(fs.init()) || visit(fs.condition()) || visit(fs.update()) || visit(fs.body());
+            if (n instanceof DeclStatement ds) return visit(ds.initializer());
+            if (n instanceof BinaryExpr b) return visit(b.left()) || visit(b.right());
+            if (n instanceof UnaryExpr u) return visit(u.operand());
+            if (n instanceof AssignExpr ae) return visit(ae.target()) || visit(ae.value());
+            if (n instanceof MemberAccessExpr m) return visit(m.target());
+            if (n instanceof TernaryExpr t) return visit(t.condition()) || visit(t.thenExpr()) || visit(t.elseExpr());
+            if (n instanceof FunctionDecl fd) return visit(fd.body());
+            return false;
+        }
+    }
+
     private static final class Finder {
         final String name;
         final boolean callOnly;
@@ -471,13 +513,30 @@ private static Result inject(TypeDef td) {
         if (!hasAnyMethod(td)) {
             return new Result(td, false);
         }
+        // Only inject _PSketch if the class actually uses Processing API.
+        // Classes that only use operators and member access (like Vec3) are
+        // pure data types -- injecting _PSketch breaks aggregate initialization.
+        if (!usesBareFunctionCalls(td)) {
+            return new Result(td, false);
+        }
         List<String> newBases = new ArrayList<>(td.baseClasses());
-        newBases.add("virtual _PSketch"); // codegen renders "public " prefix; see CodeGen notes if/when wired in
+        newBases.add("virtual _PSketch");
         TypeDef injected = new TypeDef(td.kind(), td.name(), td.templateParams(), newBases, td.members(),
             td.line(), td.col(), td.leadingComments());
         return new Result(injected, true);
     }
 
+    private static boolean usesBareFunctionCalls(TypeDef td) {
+        for (TopLevelItem member : td.members()) {
+            if (member instanceof FunctionDecl fd && fd.body() != null) {
+                if (NameUsageScanner.containsBareFunctionCall(fd)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     /**
      * True if this TypeDef has at least one FunctionDecl member. The
      * original's "&& !body.contains(\"constexpr\")" exclusion is not
@@ -539,7 +598,7 @@ public static List<FunctionDecl> generate(List<FunctionDecl> hoistedFunctions) {
                 fd.returnType(), fd.name(), fd.templateParams(), fd.params(),
                 fd.initializerList(), null /* body -- this is what makes it a forward decl */,
                 fd.isConstructor(), fd.isDestructor(), fd.isVirtual(), fd.isOverride(),
-                fd.isConst(), fd.isStatic(), false /* isPureVirtual -- never applies to a hoisted free function */,
+                fd.isConst(), fd.isConstexpr(), fd.isStatic(), false /* isPureVirtual -- never applies to a hoisted free function */,
                 fd.line(), fd.col(), List.of() /* no comments on the forward decl */
             ));
         }