Registry fixes: postfix++→prefix, float f-suffix, final→constexpr, color var shadowing

CodeGen:
- PostfixExpr ++/-- normalized to prefix form universally (Rule C)
- Float literals without f/F suffix get f appended (Rule D)

Parser:
- Java 'final' qualifier consumed and mapped to constexpr (Rule E)

CppBuild:
- fixColorTypes: skip single-letter variables and for-loop counters
  from int→color rewrite (fixes Problem 1.1: c/r shadowing by color type)
- E0006: single-letter and two-letter-lowercase identifiers skipped

Author: pepc84

mode/CppMode.jar

@@ -836,6 +836,8 @@ public static String renderTypeRef(TypeRef t) {
             if (nt.baseName().startsWith("decltype(")) return nt.baseName();
             StringBuilder sb = new StringBuilder();
             if (nt.isConst()) sb.append("const ");
+            // Dependent type: "typename T::value_type" -- prepend typename
+            if (nt.baseName().contains("::") && !nt.baseName().startsWith("std::") && !nt.baseName().contains("(")) sb.append("typename ");
             sb.append(nt.baseName());
             if (!nt.templateArgs().isEmpty()) {
                 sb.append('<');
@@ -878,7 +880,17 @@ public static String renderTypeRef(TypeRef t) {
     // =====================================================================
 
     public static String renderExpr(Expr e) {
-        if (e instanceof Literal lit) return lit.text();
+        if (e instanceof Literal lit) {
+            String txt = lit.text();
+            // Append f suffix to float literals without one -- prevents
+            // double/float ambiguity on overloaded Processing API functions
+            if (lit.kind() == Literal.Kind.FLOAT
+                    && !txt.endsWith("f") && !txt.endsWith("F")
+                    && !txt.endsWith("d") && !txt.endsWith("D")) {
+                txt = txt + "f";
+            }
+            return txt;
+        }
         if (e instanceof Identifier id) return id.name();
         if (e instanceof ScopedName sn) return sn.joined();
 
@@ -946,7 +958,11 @@ public static String renderExpr(Expr e) {
             return u.op() + renderExpr(u.operand());
         }
         if (e instanceof PostfixExpr p) {
-            return renderExpr(p.operand()) + p.op();
+            // Normalize postfix ++/-- to prefix: better C++ style, avoids
+            // postfix operator resolution issues inside user class bodies
+            if (p.op().equals("++") || p.op().equals("--"))
+                return p.op() + renderExpr(p.operand());
+            return renderExpr(p.operand()) + p.op(); // "..." pack expansion etc.
         }
         if (e instanceof AssignExpr a) {
             return renderExpr(a.target()) + " = " + renderExpr(a.value());

src/java/CodeGen.java

@@ -2212,7 +2212,16 @@ private String fixColorTypes(String code) {
     code = sb3.toString();
 
     // Pass 4: replace int varname declarations with color varname for all colorVars
+    // Skip variables declared as loop counters or with explicit int literals
+    // to avoid mistyping loop vars like "for (int c = 0; ...)" as color
+    java.util.regex.Pattern forLoopDecl = java.util.regex.Pattern.compile(
+        "\\bfor\\s*\\(\\s*int\\s+(\\w+)");
+    java.util.Set<String> loopVars = new java.util.HashSet<>();
+    java.util.regex.Matcher lm = forLoopDecl.matcher(code);
+    while (lm.find()) loopVars.add(lm.group(1));
     for (String v : colorVars) {
+      if (loopVars.contains(v)) continue; // skip loop counters
+      if (v.length() == 1) continue; // skip single-letter vars (likely loop counters or params)
       code = code.replaceAll("\\bint\\s+(" + Pattern.quote(v) + ")\\b", "color $1");
     }
 
@@ -2418,6 +2427,10 @@ private void checkForJavaStaticCallSyntax(String code, RunnerListener listener)
       String firstName = t0.text();
       if (firstName.isEmpty() || !Character.isUpperCase(firstName.charAt(0))) continue;
       if (instanceTypes.contains(firstName)) continue; // known instance type
+      // Single-letter uppercase = almost certainly a template param (T, S, U, K, V, etc.)
+      if (firstName.length() == 1) continue;
+      // Two-letter uppercase combos commonly used as template params: Ts, Vs, etc.
+      if (firstName.length() == 2 && Character.isLowerCase(firstName.charAt(1))) continue;
       // 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

src/java/CppBuild.java

@@ -1117,10 +1117,13 @@ private List<TopLevelItem> parseFunctionOrVariable(List<CppLexerToken> leadingCo
 
         boolean isVirtual = matchKeyword("virtual");
         boolean isStatic = matchKeyword("static");
+        // Java "final" → C++ constexpr (for literals) or const
+        boolean isFinal = check(CppLexerTokenType.IDENTIFIER) && peek().text().equals("final");
+        if (isFinal) advance();
         matchKeyword("inline");
         matchKeyword("volatile"); // consume volatile qualifier
-        boolean isConst = matchKeyword("const");
-        boolean isConstexprFn = matchKeyword("constexpr") || matchKeyword("consteval");
+        boolean isConst = matchKeyword("const") || isFinal;
+        boolean isConstexprFn = matchKeyword("constexpr") || matchKeyword("consteval") || isFinal;
         if (isConstexprFn && !isConst) isConst = true;
         matchKeyword("constinit");
         if (!isVirtual) isVirtual = matchKeyword("virtual"); // constexpr virtual
@@ -2904,7 +2907,8 @@ private Expr parseInitializerElement() {
             advance(); // consume "="
         }
         Expr e = parseExpr();
-        matchPunct("..."); // pack expansion in brace-init: "{args...}"
+        if (matchPunct("...")) // pack expansion in brace-init: "{args...}"
+            e = new PostfixExpr("...", e, e.line(), e.col(), List.of());
         return e;
     }