Fix seven parser/lexer/evaluator bugs (#36, #40, #41, #54, #55, #56, #59)

- #36: for-loop over a bracketed point-list literal (e.g. [[1,2,3],[4,5,6]])
  no longer flattens into scalars; only the unbracketed expression form
  (for (v = someVar)) still expands a vector value.
- #40/#41: lexer now accepts trailing-dot floats (3.) per OpenSCAD grammar,
  and only consumes an 'e'/'E' exponent (and its sign) when at least one
  digit follows, so a bare sign/exponent no longer swallows an adjacent
  operator or gets silently truncated.
- #54: unrecognized top-level tokens now emit a diagnostic before being
  skipped, instead of being silently dropped.
- #55: named-parameter detection now rejects Number/String tokens as param
  names (e.g. cube(3=5) is a parse error) while still accepting
  keyword-named params like scale=.
- #56: unterminated block comments are now logged as a Warning, matching
  the adjacent comment's stated non-fatal intent, instead of as an Error.
- #59: MeshCache(0) no longer grows unbounded — insertion is skipped
  entirely when maxEntries == 0 instead of relying on a no-op eviction.

Verified via a scratch CMake target building the lang/csg test sources
(Catch2/glm/spdlog only, no Vulkan/Manifold) under -Wall -Wextra -Wpedantic
-Werror: 352 test cases / 1823 assertions pass, including new regression
tests for each fix.

Author: claude

src/csg/CsgEvaluator.cpp

@@ -441,8 +441,15 @@ CsgNodePtr CsgEvaluator::evalFor(const ForNode& node, const glm::mat4& xform, co
         else
             for (double v = start; v >= end - 1e-10 && (int)values.size() < kMaxIter; v += step)
                 values.push_back(Value::fromNumber(v));
+    } else if (node.range.isBracketedList) {
+        // Bracketed list literal `[a, b, c]` — each element is its own loop
+        // value, even if it evaluates to a vector (e.g. a point list
+        // `[[1,2,3], [4,5,6]]` must yield two vector iterations, not six
+        // scalars).
+        for (const auto& e : node.range.list)
+            values.push_back(m_interp->evaluate(*e));
     } else {
-        // List form — evaluate each element; if one evaluates to a Vector,
+        // Expression form `for (v = expr)` — expr must evaluate to a vector;
         // expand it so that `for (pt = pts)` iterates over pts' elements.
         for (const auto& e : node.range.list) {
             Value v = m_interp->evaluate(*e);

src/csg/MeshCache.cpp

@@ -15,6 +15,9 @@ manifold::Manifold MeshCache::getOrCompute(const std::string& key,
 
     // Cache miss — compute, then insert
     manifold::Manifold mesh = compute();
+    if (m_maxEntries == 0)
+        return mesh; // caching disabled — nothing to insert or evict
+
     if (m_map.size() >= m_maxEntries)
         evictLru();
 

src/lang/AST.h

@@ -112,6 +112,10 @@ struct ForRange {
     ExprPtr          step;            // range form — nullptr means step of 1
     ExprPtr          end;             // range form — required
     std::vector<ExprPtr> list;        // list form
+    // true when `list` came from a bracketed literal `[a, b, c]` (each entry
+    // is its own loop value, even if it evaluates to a vector); false when it
+    // came from `for (v = expr)` (single expr, expanded if it's a vector).
+    bool             isBracketedList = false;
 };
 
 struct ForNode {

src/lang/Lexer.cpp

@@ -251,14 +251,19 @@ Token Lexer::scanNumber(uint32_t startOffset) {
     // Integer part
     while (std::isdigit(static_cast<unsigned char>(peek()))) advance();
 
-    // Fractional part
-    if (peek() == '.' && std::isdigit(static_cast<unsigned char>(peek(1)))) {
+    // Fractional part — OpenSCAD allows a trailing dot with no digits after
+    // it (e.g. `3.`), so only require a leading digit before the dot.
+    if (peek() == '.') {
         advance(); // consume '.'
         while (std::isdigit(static_cast<unsigned char>(peek()))) advance();
     }
 
-    // Exponent
-    if (peek() == 'e' || peek() == 'E') {
+    // Exponent — only consume 'e'/'E' (and an optional sign) if at least one
+    // digit follows; otherwise leave them unconsumed so a bare 'e'/'-'/'+'
+    // isn't silently swallowed into a truncated number.
+    if ((peek() == 'e' || peek() == 'E') &&
+        (std::isdigit(static_cast<unsigned char>(peek(1))) ||
+         ((peek(1) == '+' || peek(1) == '-') && std::isdigit(static_cast<unsigned char>(peek(2)))))) {
         advance();
         if (peek() == '+' || peek() == '-') advance();
         while (std::isdigit(static_cast<unsigned char>(peek()))) advance();
@@ -396,11 +401,15 @@ void Lexer::skipBlockComment() {
     // Unterminated block comment — not a fatal error, just note it
     SourceLoc loc;
     loc.line = m_line; loc.col = m_col; loc.offset = static_cast<uint32_t>(m_pos);
-    addError("unterminated block comment", loc);
+    addWarning("unterminated block comment", loc);
 }
 
 void Lexer::addError(const std::string& msg, SourceLoc loc) {
     m_diags.push_back({DiagLevel::Error, msg, loc, m_filePath});
 }
 
+void Lexer::addWarning(const std::string& msg, SourceLoc loc) {
+    m_diags.push_back({DiagLevel::Warning, msg, loc, m_filePath});
+}
+
 } // namespace chisel::lang

src/lang/Lexer.h

@@ -41,6 +41,7 @@ class Lexer {
     void  skipBlockComment();
 
     void addError(const std::string& msg, SourceLoc loc);
+    void addWarning(const std::string& msg, SourceLoc loc);
 
     // ---- state ------------------------------------------------------------
     std::string_view m_source;

src/lang/Parser.cpp

@@ -5,6 +5,16 @@
 
 namespace chisel::lang {
 
+// A token can be used as a named-parameter name (e.g. `scale=`) if it's an
+// identifier or a keyword scanned as one (both carry non-empty `.text`).
+// Number/String literals also carry non-empty `.text` but must NOT be
+// accepted as param names — `cube(3=5)` should be a syntax error, not a
+// named param called "3".
+static bool isParamNameToken(const Token& t) {
+    return !t.text.empty() && t.kind != TokenKind::Number && t.kind != TokenKind::String &&
+           t.kind != TokenKind::SpecialVar;
+}
+
 // ---------------------------------------------------------------------------
 // Constructor
 // ---------------------------------------------------------------------------
@@ -97,8 +107,9 @@ void Parser::parseStatement(ParseResult& result) {
     auto node = parseNode();
     if (node) {
         result.roots.push_back(std::move(node));
-    } else {
-        if (!atEnd()) advance(); // skip unrecognised token
+    } else if (!atEnd()) {
+        addError("unexpected token '" + peek().text + "' at statement position", peek().loc);
+        advance(); // skip unrecognised token
     }
     match(TokenKind::Semicolon);
 }
@@ -350,7 +361,7 @@ AstNodePtr Parser::parseColor() {
     while (!check(TokenKind::RParen) && !atEnd()) {
         const size_t prevPos = m_pos; // guard against zero-progress infinite loops
 
-        if (peek(1).kind == TokenKind::Equals && !peek().text.empty()) {
+        if (peek(1).kind == TokenKind::Equals && isParamNameToken(peek())) {
             std::string name = peek().text;
             advance(); // name
             advance(); // =
@@ -431,6 +442,7 @@ AstNodePtr Parser::parseFor() {
         } else {
             // List form: [first, ...]
             node.range.isRange = false;
+            node.range.isBracketedList = true;
             node.range.list.push_back(std::move(first));
             while (match(TokenKind::Comma)) {
                 if (check(TokenKind::RBracket)) break;
@@ -501,8 +513,7 @@ void Parser::parseParamList(std::unordered_map<std::string, ExprPtr>& params,
         }
 
         // Named param: any token (Ident or keyword like 'scale') followed by '='
-        if (peek(1).kind == TokenKind::Equals && !peek().text.empty() &&
-            !check(TokenKind::SpecialVar)) {
+        if (peek(1).kind == TokenKind::Equals && isParamNameToken(peek())) {
             std::string name = peek().text;
             advance(); // name token
             advance(); // =
@@ -916,7 +927,7 @@ void Parser::parseExtrusionParams(std::unordered_map<std::string, ExprPtr>& para
             continue;
         }
         // Accept any token (Ident or keyword like 'scale') when followed by '='
-        if (peek(1).kind == TokenKind::Equals && !peek().text.empty()) {
+        if (peek(1).kind == TokenKind::Equals && isParamNameToken(peek())) {
             std::string name = advance().text;
             advance(); // consume '='
             params[name] = parseExpr();

tests/test_csg_evaluator.cpp

@@ -664,6 +664,32 @@ TEST_CASE("CsgEval:for empty range yields no geometry", "[csg]") {
     REQUIRE(s.roots.empty());
 }
 
+TEST_CASE("CsgEval:for over bracketed point-list literal iterates per-point, not flattened", "[csg]") {
+    // Regression test: a bracketed list literal whose own elements are
+    // vectors — the common point-list idiom — must yield one iteration per
+    // point (2), not one per flattened scalar (6).
+    auto s = evaluate("for (p = [[1,2,3], [4,5,6]]) translate(p) sphere(r=1);");
+    REQUIRE(s.roots.size() == 1);
+    const auto& b = asBool(s.roots[0]);
+    REQUIRE(b.children.size() == 2);
+    REQUIRE(asLeaf(b.children[0]).transform[3][0] == Approx(1.0f));
+    REQUIRE(asLeaf(b.children[0]).transform[3][1] == Approx(2.0f));
+    REQUIRE(asLeaf(b.children[0]).transform[3][2] == Approx(3.0f));
+    REQUIRE(asLeaf(b.children[1]).transform[3][0] == Approx(4.0f));
+    REQUIRE(asLeaf(b.children[1]).transform[3][1] == Approx(5.0f));
+    REQUIRE(asLeaf(b.children[1]).transform[3][2] == Approx(6.0f));
+}
+
+TEST_CASE("CsgEval:for over variable holding a point list still expands per-point", "[csg]") {
+    // Same point-list idiom via a variable (expression form) — must keep
+    // working the same way it did before the bracketed-list fix.
+    auto s = evaluate("pts = [[1,2,3], [4,5,6]]; for (p = pts) translate(p) sphere(r=1);");
+    REQUIRE(s.roots.size() == 1);
+    const auto& b = asBool(s.roots[0]);
+    REQUIRE(b.children.size() == 2);
+    REQUIRE(asLeaf(b.children[1]).transform[3][0] == Approx(4.0f));
+}
+
 // ---------------------------------------------------------------------------
 // User-defined modules
 // ---------------------------------------------------------------------------

tests/test_lexer.cpp

@@ -125,6 +125,48 @@ TEST_CASE("Lexer:leading dot float", "[lexer]") {
     REQUIRE(t[0].numberValue() == Approx(0.5));
 }
 
+TEST_CASE("Lexer:trailing dot float", "[lexer]") {
+    auto t = lex("3.");
+    REQUIRE(t.size() == 1);
+    REQUIRE(t[0].kind == TokenKind::Number);
+    REQUIRE(t[0].numberValue() == Approx(3.0));
+}
+
+TEST_CASE("Lexer:trailing dot float followed by comma", "[lexer]") {
+    auto t = kinds("[3., 1, 1]");
+    REQUIRE(t == std::vector{TokenKind::LBracket, TokenKind::Number, TokenKind::Comma,
+                              TokenKind::Number, TokenKind::Comma, TokenKind::Number,
+                              TokenKind::RBracket});
+}
+
+TEST_CASE("Lexer:exponent with digits", "[lexer]") {
+    auto t = lex("5e3");
+    REQUIRE(t.size() == 1);
+    REQUIRE(t[0].kind == TokenKind::Number);
+    REQUIRE(t[0].numberValue() == Approx(5000.0));
+}
+
+TEST_CASE("Lexer:exponent with signed digits", "[lexer]") {
+    auto t = lex("5e+3");
+    REQUIRE(t.size() == 1);
+    REQUIRE(t[0].numberValue() == Approx(5000.0));
+}
+
+TEST_CASE("Lexer:bare 'e' after number is not consumed as exponent", "[lexer]") {
+    // No digits follow 'e', so it must not be swallowed into the number —
+    // it should tokenize as a separate identifier.
+    auto t = kinds("5e;");
+    REQUIRE(t == std::vector{TokenKind::Number, TokenKind::Ident, TokenKind::Semicolon});
+}
+
+TEST_CASE("Lexer:exponent sign without digits does not eat a following operator", "[lexer]") {
+    // Previously `2e-h` would swallow the '-' into a truncated "2e-" number,
+    // silently dropping the intended binary minus. It must now tokenize as
+    // Number(2) Ident(e) Minus Ident(h).
+    auto t = kinds("2e-h");
+    REQUIRE(t == std::vector{TokenKind::Number, TokenKind::Ident, TokenKind::Minus, TokenKind::Ident});
+}
+
 TEST_CASE("Lexer:negative number", "[lexer]") {
     // '-' is now always a Minus token; negation is handled by the parser.
     auto t = lex("-1");
@@ -200,6 +242,14 @@ TEST_CASE("Lexer:block comment skipped", "[lexer]") {
     REQUIRE(kinds("cu/* mid */be") == (std::vector{TokenKind::Ident, TokenKind::Ident}));
 }
 
+TEST_CASE("Lexer:unterminated block comment is a warning, not an error", "[lexer]") {
+    Lexer lexer("cube /* never closed");
+    lexer.tokenize();
+    REQUIRE_FALSE(lexer.hasErrors());
+    REQUIRE(lexer.diagnostics().size() == 1);
+    REQUIRE(lexer.diagnostics()[0].level == DiagLevel::Warning);
+}
+
 // ---------------------------------------------------------------------------
 // Identifiers (unrecognised words)
 // ---------------------------------------------------------------------------

tests/test_parser.cpp

@@ -716,3 +716,33 @@ TEST_CASE("Parser:include inside a block is a parse error, not silently dropped"
     const auto& u = std::get<BooleanNode>(*r.roots[0]);
     REQUIRE(u.children.size() == 1);
 }
+
+// ---------------------------------------------------------------------------
+// Diagnostics for otherwise-silent parse gaps
+// ---------------------------------------------------------------------------
+TEST_CASE("Parser:unrecognized top-level statement reports an error", "[parser]") {
+    // A bare identifier not followed by '(' or '=' is not a valid statement
+    // and must not be silently skipped.
+    Lexer lexer("y;");
+    auto tokens = lexer.tokenize();
+    Parser parser(std::move(tokens));
+    auto r = parser.parse();
+    REQUIRE(parser.hasErrors());
+    REQUIRE(r.roots.empty());
+}
+
+TEST_CASE("Parser:numeric token as a named-param name is a parse error", "[parser]") {
+    // `3=5` must not be silently accepted as a named param keyed "3".
+    Lexer lexer("cube(3=5);");
+    auto tokens = lexer.tokenize();
+    Parser parser(std::move(tokens));
+    parser.parse();
+    REQUIRE(parser.hasErrors());
+}
+
+TEST_CASE("Parser:keyword-named param still parses as a named param", "[parser]") {
+    // Regression guard: the numeric-token fix must not break keyword-named
+    // params like 'scale=' (a keyword token, not Number/String).
+    auto r = parse("linear_extrude(height=5, scale=2) square(1);");
+    REQUIRE(r.roots.size() == 1);
+}