Parser: pack expansion, typename, lambda captures, template args

- parseTemplateArgList: consume trailing ... (pack expansion Ts...)
- parseTemplateArg: handle standalone ... tokens
- parseInitializerElement: allow ... after expr in brace-init {args...}
- parseCapture: pack expansion in lambda capture [args...]
- parseTypeRefAfterConst: consume typename for dependent types
- parseBaseClassEntry: preserve virtual keyword in output
- PSketchInjector: skip injection for transitive _PSketch inheritors
- ClassHoister: full definition position beats forward decl position
- CppBuild: out-of-class static members hoisted to namespace scope
- CppBuild: depResult.hoistedVariables emitted before class definitions
- CppBuild: E0006 Java static call syntax detection
- Processing.h: KEY_0-KEY_9, SPACE constants

Author: pepc84

mode/CppMode.jar

@@ -1027,6 +1027,7 @@ private File writeSketchImpl(RunnerListener listener) throws IOException {
     checkForUnsupportedJavaArraySyntax(code, listener);
     checkForArrayListGetValueCopy(code, listener);
     checkForArrayListGetDotAccess(code, listener);
+    checkForJavaStaticCallSyntax(code, listener);
     code = stripRawStringLiterals(code);
     code = code.replaceAll("(?<=[0-9a-fA-FxXbB])'(?=[0-9a-fA-F])", "");
     code = javaToC(code);
@@ -2356,6 +2357,73 @@ private void checkForArrayListGetDotAccess(String code, RunnerListener listener)
     }
   }
 
+  // [E0006] Java static method/field call syntax: ClassName.member must be ClassName::member in C++
+  //
+  // Generalized rule: any identifier that starts with an uppercase letter followed
+  // by a "." and then another identifier (with optional "(") is likely a Java
+  // static access pattern. This covers:
+  //   Integer.parseInt(...)    -> Integer::parseInt(...)
+  //   Math.PI                  -> Math::PI (or just PI)
+  //   MyClass.CONSTANT         -> MyClass::CONSTANT
+  //   Collections.sort(...)    -> Collections::sort(...) or std::sort
+  //
+  // Excluded: known instance-access patterns where the variable name
+  // happens to start with uppercase (e.g. PImage, PFont, PVector variables).
+  private void checkForJavaStaticCallSyntax(String code, RunnerListener listener) {
+    List<CppLexerToken> tokens;
+    try { tokens = new CppLexer(code).tokenize(); } catch (Exception e) { return; }
+    // Types known to be used as instances (not static-only classes)
+    java.util.Set<String> instanceTypes = java.util.Set.of(
+        "PImage", "PFont", "PVector", "PShape", "PGraphics",
+        "ArrayList", "IntList", "FloatList", "StringList",
+        "String", "Array", "Table", "TableRow", "JSONObject", "JSONArray",
+        "PrintWriter", "BufferedReader", "XML"
+    );
+    // Definitely-static classes (always trigger E0006)
+    java.util.Set<String> staticClasses = java.util.Set.of(
+        "Integer", "Float", "Double", "Long", "Boolean", "Character",
+        "Byte", "Short", "Math", "Arrays", "Collections", "System",
+        "Thread", "Runtime", "Class", "Objects"
+    );
+    for (int i = 0; i + 2 < tokens.size(); i++) {
+      CppLexerToken t0 = tokens.get(i);
+      CppLexerToken t1 = tokens.get(i + 1);
+      CppLexerToken t2 = tokens.get(i + 2);
+      // Pattern: IDENTIFIER . IDENTIFIER where first IDENTIFIER starts uppercase
+      if (t0.type() != CppLexerTokenType.IDENTIFIER) continue;
+      if (!t1.isPunct(".")) continue;
+      if (t2.type() != CppLexerTokenType.IDENTIFIER) continue;
+      String firstName = t0.text();
+      if (firstName.isEmpty() || !Character.isUpperCase(firstName.charAt(0))) continue;
+      if (instanceTypes.contains(firstName)) continue; // known instance type
+      // Only fire for known static classes OR if preceded by nothing
+      // (i.e. not "obj.UpperMethod()" which is a method call)
+      // Check context: if previous token is ")", "]", or identifier, skip
+      boolean preceded = i > 0 && (
+          tokens.get(i-1).isPunct(")")
+          || tokens.get(i-1).isPunct("]")
+          || tokens.get(i-1).isPunct(">")
+          || tokens.get(i-1).type() == CppLexerTokenType.IDENTIFIER);
+      if (preceded && !staticClasses.contains(firstName)) continue;
+      // Check that next token after t2 is "(" or nothing method-like
+      boolean isCall = i + 3 < tokens.size() && tokens.get(i + 3).isPunct("(");
+      boolean isField = !isCall; // field access like Math.PI
+      if (!staticClasses.contains(firstName) && !isCall) continue; // only fire on known statics for field access
+      int line = t0.line();
+      String url = getWebsiteBaseUrl() + "/error/E0006.html";
+      String access = t2.text() + (isCall ? "(...)" : "");
+      String msg =
+        "\n[E0006] Java static access syntax is not valid in C++.\n" +
+        "  Line " + line + ": \"" + firstName + "." + access + "\"\n" +
+        "  In C++, static members use :: not .:\n" +
+        "    " + firstName + "::" + access + "\n" +
+        "  Reference: " + url + "\n";
+      System.err.println(msg);
+      listener.statusError("E0006: use " + firstName + "::" + t2.text() + " not . -- see console");
+      throw new AlreadyReportedException("E0006: Java static access syntax -- see console.");
+    }
+  }
+
   private void checkForUnsupportedJavaArraySyntax(String code, RunnerListener listener) {
     try {
       CppJavaArrayCheck.check(code);

src/java/CppBuild.java

@@ -1413,6 +1413,8 @@ private TypeRef parseTypeRef(boolean leadingConst) {
     }
 
     private TypeRef parseTypeRefAfterConst(boolean isConst) {
+        // typename X::Y -- dependent type name, consume and continue
+        if (checkKeyword("typename")) advance();
 
         // decltype(expr) -- C++11 computed type
         if (checkKeyword("decltype")) {
@@ -1570,8 +1572,11 @@ private List<TypeRef> parseTemplateArgList() {
         List<TypeRef> args = new ArrayList<>();
         if (!checkOp(">")) {
             args.add(parseTemplateArg());
+            matchPunct("..."); // trailing pack expansion: "Ts..."
             while (matchPunct(",")) {
+                if (checkOp(">") || checkOp(">>")) break;
                 args.add(parseTemplateArg());
+                matchPunct("..."); // trailing pack expansion
             }
         }
         // Note: ">>"  closing two nested template lists at once (e.g.
@@ -1647,6 +1652,12 @@ private TypeRef parseTemplateArg() {
             dt.append(")");
             return new NamedType(dt.toString(), List.of(), 0, false, false);
         }
+        // Pack expansion "..." trailing a type: "Ts..." in template args
+        // Also handles standalone "..." as a variadic marker
+        if (checkPunct("...")) {
+            advance();
+            return new NamedType("...", List.of(), 0, false, false);
+        }
         // sizeof expression: sizeof(T) or sizeof...(Args)
         if (checkKeyword("sizeof")) {
             int save = pos; advance();
@@ -2451,7 +2462,9 @@ private Expr parseInitializerElement() {
         if (checkPunct("{")) {
             return parseInitializerList(); // anonymous nested brace-init
         }
-        return parseExpr(); // expression (may itself end with {} for named brace-init via parsePrimary)
+        Expr e = parseExpr();
+        matchPunct("..."); // pack expansion in brace-init: "{args...}"
+        return e;
     }
 
     /**
@@ -2537,6 +2550,8 @@ private Capture parseCapture() {
         // "this" is a keyword capture: [this] or [&this]
         if (checkKeyword("this")) { advance(); return new Capture("this", byRef); }
         String name = expectIdentifier().text();
+        // Pack expansion in capture: "[args...]"
+        if (checkPunct("...")) { advance(); name = name + "..."; }
         // Init-capture: "z = z * 2" or "w = x + y" -- encode into name string
         if (checkOp("=")) {
             advance();