openscad-parser 2.6.1__tar.gz → 3.1.0__tar.gz

{openscad_parser-2.6.1 → openscad_parser-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_parser
-Version: 2.6.1
+Version: 3.1.0
 Summary: A PEG parser to read OpenSCAD language source code, with optional AST tree generation.
 Keywords: openscad,openscad parser,parser
 Author: Revar Desmera
@@ -184,12 +184,39 @@ Use ``getASTfromLibraryFile()`` to find and parse library files using OpenSCAD's
 The function searches for library files in this order:
 
 1. Directory of the current file (if provided)
-2. Directories in the ``OPENSCADPATH`` environment variable
-3. Platform-specific default library directories:
-   - Windows: ``~/Documents/OpenSCAD/libraries``
+2. Directories in the ``OPENSCADPATH`` environment variable, which add to the
+   directories below rather than replacing them, as in OpenSCAD
+3. The platform's libraries folder:
+
+   - Windows: ``OpenSCAD\libraries`` in the Documents folder Windows reports
+     (under OneDrive when Known Folder Move is on)
    - macOS: ``~/Documents/OpenSCAD/libraries``
    - Linux: ``~/.local/share/OpenSCAD/libraries``
 
+4. A ``libraries`` directory beside the installed package
+
+``librarySearchDirs(currfile)`` returns this list, and a not-found error names
+every directory in it.
+
+Strict Commas
+~~~~~~~~~~~~~
+
+OpenSCAD accepts a trailing comma almost everywhere. OpenSCAD 2021.01 did not:
+it rejected one after a call's last argument (``cube(1,)``) and after the last
+assignment of a ``let``/``for``/``intersection_for`` (``let(x=1,)``), while
+accepting it in list literals, list comprehensions and parameter lists. To
+parse as 2021.01 did:
+
+.. code-block:: python
+
+    from openscad_parser import strict_commas
+
+    with strict_commas():
+        ast = getASTfromFile("model.scad")   # None if it uses a rejected comma
+
+The mode nests, restores on exit, and every AST cache keys on it, so a strict
+parse is never served a lenient tree.
+
 Advanced AST Generation
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -432,6 +459,7 @@ Expressions
 - ``AssertOp(arguments: list[Argument], body: Expression)``: assert clause  ``assert(arguments) body``
 - ``FunctionLiteral(parameters: list[ParameterDeclaration], body: Expression)``: Anonymous function expression  ``function(parameters) body``
 - ``PrimaryCall(left: Expression, arguments: list[Argument])``: Function calls  ``left(arguments)``
+- ``RenderExpression(arguments: list[Argument], children: list[ModuleInstantiation])``: Geometry measured as a value  ``render(arguments) { children }``. Braces required; ``render`` stays usable as an ordinary name. Not part of upstream OpenSCAD
 - ``PrimaryIndex(left: Expression, index: Expression)``: Array indexing ``left[index]``
 - ``PrimaryMember(left: Expression, member: Identifier)``: Member access ``left.member``
 
@@ -535,7 +563,7 @@ Main Functions
 
 ``getASTfromLibraryFile(currfile: str, libfile: str, include_comments: bool = False, process_includes: bool = True)``
     Find and parse an OpenSCAD library file using OpenSCAD's search path rules.
-    Searches in: current file directory, OPENSCADPATH, and platform default paths.
+    Searches the directories ``librarySearchDirs(currfile)`` returns.
 
     :param currfile: Full path to the current OpenSCAD file (can be empty string)
     :param libfile: Partial or full path to the library file to find
@@ -565,11 +593,16 @@ Main Functions
     This function removes all cached AST trees from memory.
 
 ``build_scopes(ast: list[ASTNode]) -> Scope``
-    Build a scope tree over an AST and attach a ``scope`` attribute to every node.
+    Build a scope tree over an AST, recording every node's scope in a ``ScopeTable``
+    hung on the root (``root.table``). Read a node's scope with ``root.scope_of(node)``.
 
     :param ast: A list of top-level AST nodes (as returned by the ``getAST*`` functions)
     :returns: The root ``Scope`` object
 
+``build_scopes_into(ast: list[ASTNode], table: ScopeTable) -> Scope``
+    The same, recording into a ``ScopeTable`` the caller owns, so several roots (one per
+    ``use``\ d file, say) can be read back through one table.
+
 ``Scope``
     Represents a lexical scope with three independent namespaces (variables, functions,
     modules), mirroring OpenSCAD's scoping rules.
@@ -1006,14 +1039,21 @@ names according to OpenSCAD's three-namespace scoping rules::
     print(root_scope.lookup_variable("x"))   # Assignment node
     print(root_scope.lookup_module("box"))   # ModuleDeclaration node
 
-    # Each AST node has a .scope attribute pointing to its enclosing scope
+    # Every node's enclosing scope, as this pass built it
     box_decl = ast[1]
     cube_call = box_decl.children[0]
-    print(cube_call.scope.lookup_variable("size"))  # ParameterDeclaration node
-
-``build_scopes(ast)`` returns the root ``Scope`` object and attaches a ``scope`` attribute
-to every node in the tree. Scopes form a parent chain so lookups fall through to enclosing
-scopes automatically. Declarations (variables, functions, modules) inside a block are
+    print(root_scope.scope_of(cube_call).lookup_variable("size"))  # ParameterDeclaration node
+
+``build_scopes(ast)`` returns the root ``Scope`` object and records the scope of every node
+in the tree in ``root_scope.table``. Scopes form a parent chain so lookups fall through to
+enclosing scopes automatically.
+
+A node's scope is not an attribute of the node. An included file is parsed once and its
+nodes are shared by every file that includes it, but ``include`` puts them in the
+*includer's* scope, so the same node sits in a different scope for each includer. Each
+``build_scopes()`` call therefore has its own table, and two files that include the same
+library can be scoped, and used, at the same time. (Before 3.0, ``node.scope`` held the
+scope of whichever file had built its scopes last.) Declarations (variables, functions, modules) inside a block are
 hoisted to the top of that block's scope before child nodes are visited.
 
 Testing

{openscad_parser-2.6.1 → openscad_parser-3.1.0}/README.rst

@@ -141,12 +141,39 @@ Use ``getASTfromLibraryFile()`` to find and parse library files using OpenSCAD's
 The function searches for library files in this order:
 
 1. Directory of the current file (if provided)
-2. Directories in the ``OPENSCADPATH`` environment variable
-3. Platform-specific default library directories:
-   - Windows: ``~/Documents/OpenSCAD/libraries``
+2. Directories in the ``OPENSCADPATH`` environment variable, which add to the
+   directories below rather than replacing them, as in OpenSCAD
+3. The platform's libraries folder:
+
+   - Windows: ``OpenSCAD\libraries`` in the Documents folder Windows reports
+     (under OneDrive when Known Folder Move is on)
    - macOS: ``~/Documents/OpenSCAD/libraries``
    - Linux: ``~/.local/share/OpenSCAD/libraries``
 
+4. A ``libraries`` directory beside the installed package
+
+``librarySearchDirs(currfile)`` returns this list, and a not-found error names
+every directory in it.
+
+Strict Commas
+~~~~~~~~~~~~~
+
+OpenSCAD accepts a trailing comma almost everywhere. OpenSCAD 2021.01 did not:
+it rejected one after a call's last argument (``cube(1,)``) and after the last
+assignment of a ``let``/``for``/``intersection_for`` (``let(x=1,)``), while
+accepting it in list literals, list comprehensions and parameter lists. To
+parse as 2021.01 did:
+
+.. code-block:: python
+
+    from openscad_parser import strict_commas
+
+    with strict_commas():
+        ast = getASTfromFile("model.scad")   # None if it uses a rejected comma
+
+The mode nests, restores on exit, and every AST cache keys on it, so a strict
+parse is never served a lenient tree.
+
 Advanced AST Generation
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -389,6 +416,7 @@ Expressions
 - ``AssertOp(arguments: list[Argument], body: Expression)``: assert clause  ``assert(arguments) body``
 - ``FunctionLiteral(parameters: list[ParameterDeclaration], body: Expression)``: Anonymous function expression  ``function(parameters) body``
 - ``PrimaryCall(left: Expression, arguments: list[Argument])``: Function calls  ``left(arguments)``
+- ``RenderExpression(arguments: list[Argument], children: list[ModuleInstantiation])``: Geometry measured as a value  ``render(arguments) { children }``. Braces required; ``render`` stays usable as an ordinary name. Not part of upstream OpenSCAD
 - ``PrimaryIndex(left: Expression, index: Expression)``: Array indexing ``left[index]``
 - ``PrimaryMember(left: Expression, member: Identifier)``: Member access ``left.member``
 
@@ -492,7 +520,7 @@ Main Functions
 
 ``getASTfromLibraryFile(currfile: str, libfile: str, include_comments: bool = False, process_includes: bool = True)``
     Find and parse an OpenSCAD library file using OpenSCAD's search path rules.
-    Searches in: current file directory, OPENSCADPATH, and platform default paths.
+    Searches the directories ``librarySearchDirs(currfile)`` returns.
 
     :param currfile: Full path to the current OpenSCAD file (can be empty string)
     :param libfile: Partial or full path to the library file to find
@@ -522,11 +550,16 @@ Main Functions
     This function removes all cached AST trees from memory.
 
 ``build_scopes(ast: list[ASTNode]) -> Scope``
-    Build a scope tree over an AST and attach a ``scope`` attribute to every node.
+    Build a scope tree over an AST, recording every node's scope in a ``ScopeTable``
+    hung on the root (``root.table``). Read a node's scope with ``root.scope_of(node)``.
 
     :param ast: A list of top-level AST nodes (as returned by the ``getAST*`` functions)
     :returns: The root ``Scope`` object
 
+``build_scopes_into(ast: list[ASTNode], table: ScopeTable) -> Scope``
+    The same, recording into a ``ScopeTable`` the caller owns, so several roots (one per
+    ``use``\ d file, say) can be read back through one table.
+
 ``Scope``
     Represents a lexical scope with three independent namespaces (variables, functions,
     modules), mirroring OpenSCAD's scoping rules.
@@ -963,14 +996,21 @@ names according to OpenSCAD's three-namespace scoping rules::
     print(root_scope.lookup_variable("x"))   # Assignment node
     print(root_scope.lookup_module("box"))   # ModuleDeclaration node
 
-    # Each AST node has a .scope attribute pointing to its enclosing scope
+    # Every node's enclosing scope, as this pass built it
     box_decl = ast[1]
     cube_call = box_decl.children[0]
-    print(cube_call.scope.lookup_variable("size"))  # ParameterDeclaration node
-
-``build_scopes(ast)`` returns the root ``Scope`` object and attaches a ``scope`` attribute
-to every node in the tree. Scopes form a parent chain so lookups fall through to enclosing
-scopes automatically. Declarations (variables, functions, modules) inside a block are
+    print(root_scope.scope_of(cube_call).lookup_variable("size"))  # ParameterDeclaration node
+
+``build_scopes(ast)`` returns the root ``Scope`` object and records the scope of every node
+in the tree in ``root_scope.table``. Scopes form a parent chain so lookups fall through to
+enclosing scopes automatically.
+
+A node's scope is not an attribute of the node. An included file is parsed once and its
+nodes are shared by every file that includes it, but ``include`` puts them in the
+*includer's* scope, so the same node sits in a different scope for each includer. Each
+``build_scopes()`` call therefore has its own table, and two files that include the same
+library can be scoped, and used, at the same time. (Before 3.0, ``node.scope`` held the
+scope of whichever file had built its scopes last.) Declarations (variables, functions, modules) inside a block are
 hoisted to the top of that block's scope before child nodes are visited.
 
 Testing

{openscad_parser-2.6.1 → openscad_parser-3.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "openscad_parser"
-version = "2.6.1"
+version = "3.1.0"
 description = "A PEG parser to read OpenSCAD language source code, with optional AST tree generation."
 readme = "README.rst"
 authors = [

{openscad_parser-2.6.1 → openscad_parser-3.1.0}/src/openscad_parser/__init__.py

@@ -5,7 +5,7 @@
 from __future__ import unicode_literals
 
 from arpeggio import ParserPython
-from .grammar import openscad_language, openscad_language_with_comments, comment, whitespace_only
+from .grammar import openscad_language, openscad_language_with_comments, comment, whitespace_only, strict_commas
 
 
 # --- The parser ---
@@ -16,7 +16,10 @@ def getOpenSCADParser(reduce_tree=False, debug=False, include_comments=False):
     Args:
         reduce_tree: If True, reduce the parse tree (default: False)
         debug: If True, enable debug output (default: False)
-        include_comments: If True, include comments in the AST instead of skipping them (default: False)
+        include_comments: If True, a grammar that parses comments at the points
+            it lists (default: False). The getAST* functions no longer use it:
+            they parse with comments as whitespace and attach them afterwards
+            (openscad_parser.ast.comments), which accepts a comment anywhere.
     
     Returns:
         ParserPython instance configured for OpenSCAD parsing

{openscad_parser-2.6.1 → openscad_parser-3.1.0}/src/openscad_parser/ast/__init__.py

@@ -1,3 +1,4 @@
+import functools
 import hashlib
 import json
 import os
@@ -5,7 +6,9 @@ import pickle
 import platform
 from typing import Optional
 from arpeggio import NoMatch
-from openscad_parser import getOpenSCADParser
+from openscad_parser import getOpenSCADParser, strict_commas
+from openscad_parser.grammar import _STRICT_COMMAS
+from .comments import _attach_all_comments
 from .source_map import SourceMap, process_includes as process_includes_func
 
 # Import all AST nodes from nodes
@@ -54,6 +57,7 @@ from .nodes import (
     LessThanOrEqualOp,
     FunctionLiteral,
     PrimaryCall,
+    RenderExpression,
     PrimaryIndex,
     PrimaryMember,
     VectorElement,
@@ -87,7 +91,7 @@ from .nodes import (
 from .builder import ASTBuilderVisitor, Position
 
 # Import scope classes
-from .scope import Scope, build_scopes
+from .scope import Scope, ScopeTable, build_scopes, build_scopes_into
 
 # Import pretty-printer
 from .pretty_print import to_openscad
@@ -105,57 +109,82 @@ from .serialization import (
 
 # --- AST convenience functions ---
 
+def _windows_documents_dir() -> str:
+    """Where Windows says My Documents is -- the same SHGetFolderPathW(
+    CSIDL_PERSONAL, SHGFP_TYPE_CURRENT) call OpenSCAD makes -- rather than
+    assuming ~/Documents: OneDrive's Known Folder Move, on by default, puts
+    it at ~/OneDrive/Documents instead."""
+    try:
+        import ctypes
+        buf = ctypes.create_unicode_buffer(260)
+        if ctypes.windll.shell32.SHGetFolderPathW(None, 5, None, 0, buf) == 0:  # CSIDL_PERSONAL, SHGFP_TYPE_CURRENT
+            return buf.value
+    except (AttributeError, OSError):  # not actually on Windows
+        pass
+    return os.path.join(os.path.expanduser("~"), "Documents")
+
+
+# Libraries shipped beside this package -- OpenSCAD's resourcePath("libraries").
+_BUNDLED_LIBRARY_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "libraries")
+
+
+def librarySearchDirs(currfile: str) -> list[str]:
+    """The directories `include`/`use` search, in order, as OpenSCAD's
+    parser_init() builds them: the including file's own directory, then
+    every OPENSCADPATH entry, then the user's libraries folder, then
+    libraries shipped beside this package.
+
+    OPENSCADPATH adds to the libraries folder rather than replacing it --
+    it used to replace it, so setting it for one library hid every other
+    one, a BOSL2 in the default folder included (openscad_cpp_parser #10).
+    """
+    dirs = []
+    if currfile:
+        dirs.append(os.path.dirname(os.path.abspath(currfile)))
+
+    system = platform.system()
+    pathsep = ";" if system == "Windows" else ":"
+    for path in os.getenv("OPENSCADPATH", "").split(pathsep):
+        expanded_path = os.path.expandvars(path)
+        if expanded_path:
+            dirs.append(expanded_path)
+
+    if system == "Windows":
+        dirs.append(os.path.join(_windows_documents_dir(), "OpenSCAD", "libraries"))
+    elif system == "Darwin":
+        dirs.append(os.path.expanduser("~/Documents/OpenSCAD/libraries"))
+    elif system == "Linux":
+        dirs.append(os.path.expanduser("~/.local/share/OpenSCAD/libraries"))
+    # ponytail: only the folder beside the package, no ../share/openscad walk
+    dirs.append(_BUNDLED_LIBRARY_DIR)
+    return dirs
+
+
 def findLibraryFile(currfile: str, libfile: str) -> Optional[str]:
-    """Find a library file using OpenSCAD's search path rules.
-    
-    Searches for the library file in the following order:
-    1. Directory of the current file (if currfile is provided)
-    2. Directories specified in OPENSCADPATH environment variable
-    3. Platform-specific default library directories
-    
+    """Find a library file using OpenSCAD's search path rules: the first
+    directory in librarySearchDirs(currfile) that holds it.
+
     Args:
         currfile: Full path to the current OpenSCAD file (can be empty string)
         libfile: Partial or full path to the library file to find
-        
+
     Returns:
         Full path to the found library file, or None if not found
     """
-    dirs = []
-    
-    # Add directory of current file if provided
-    if currfile:
-        dirs.append(os.path.dirname(os.path.abspath(currfile)))
-    
-    # Determine path separator and default path based on platform
-    pathsep = ":"
-    dflt_path = ""
-    system = platform.system()
-    
-    if system == "Windows":  # pragma: no cover
-        dflt_path = os.path.join(os.path.expanduser("~"), "Documents", "OpenSCAD", "libraries")
-        pathsep = ";"
-    elif system == "Darwin":  # pragma: no cover
-        dflt_path = os.path.expanduser("~/Documents/OpenSCAD/libraries")
-    elif system == "Linux":  # pragma: no cover
-        dflt_path = os.path.expanduser("~/.local/share/OpenSCAD/libraries")
-    
-    # Get OPENSCADPATH from environment or use default
-    env = os.getenv("OPENSCADPATH", dflt_path)
-    if env:
-        for path in env.split(pathsep):
-            expanded_path = os.path.expandvars(path)
-            if expanded_path:
-                dirs.append(expanded_path)
-    
-    # Search for the file in each directory
-    for d in dirs:
+    for d in librarySearchDirs(currfile):
         test_file = os.path.join(d, libfile)
         if os.path.isfile(test_file):
             return test_file
-    
     return None
 
 
+def _not_found(what: str, filename: str, currfile: str) -> str:
+    """A not-found message that lists every directory searched. Naming only
+    the includer read as "only there was searched"."""
+    return f"{what} '{filename}' not found. Searched:" + "".join(
+        f"\n  {d}" for d in librarySearchDirs(currfile))
+
+
 # Alias for backward compatibility (test_ast_convenience.py imports _find_library_file)
 _find_library_file = findLibraryFile
 
@@ -251,20 +280,24 @@ def getASTfromString(code: str, include_comments: bool = False, origin: str = "<
     source_map = SourceMap()
     source_map.add_origin(origin, code)
     
-    parser = getOpenSCADParser(reduce_tree=False, include_comments=include_comments)
+    # Comments are parsed as whitespace and attached afterwards (see comments.py).
+    parser = getOpenSCADParser(reduce_tree=False)
     ast = parse_ast(parser, code, source_map=source_map)
+    if ast is not None and include_comments:
+        ast = _attach_all_comments(ast, code, origin)
     return ast
 
 
 # Module-level in-memory cache for per-file AST trees (no includes resolved)
-# Key: tuple of (absolute file path (str), include_comments (bool))
+# Key: tuple of (absolute file path (str), include_comments (bool), strict_commas (bool))
 # Value: tuple of (AST nodes, modification timestamp)
-_ast_cache: dict[tuple[str, bool], tuple[list[ASTNode] | None, float]] = {}
+_ast_cache: dict[tuple[str, bool, bool], tuple[list[ASTNode] | None, float]] = {}
 
 # Resolved (includes-expanded) cache
-# Key: tuple of (absolute file path (str), include_comments (bool), process_includes (bool))
+# Key: tuple of (absolute file path (str), include_comments (bool), process_includes (bool),
+#      strict_commas (bool))
 # Value: tuple of (AST nodes, modification timestamp)
-_resolved_cache: dict[tuple[str, bool, bool], tuple[list[ASTNode] | None, float]] = {}
+_resolved_cache: dict[tuple[str, bool, bool, bool], tuple[list[ASTNode] | None, dict[str, float]]] = {}
 
 
 def _get_disk_cache_dir() -> Optional[str]:
@@ -285,12 +318,27 @@ def _get_disk_cache_dir() -> Optional[str]:
         return None
 
 
+@functools.lru_cache(maxsize=None)
+def _ast_format_tag() -> str:
+    """Changes whenever the grammar or the AST classes do, so a pickled AST
+    from another version is never served: an older pickle lacks any field
+    added since (RangeLiteral.implicit_step, say) and reads its default."""
+    here = os.path.dirname(os.path.abspath(__file__))
+    h = hashlib.sha256()
+    for path in (os.path.join(here, "..", "grammar.py"), os.path.join(here, "nodes.py"),
+                 os.path.join(here, "builder.py"), os.path.join(here, "__init__.py"),
+                 os.path.join(here, "comments.py")):
+        with open(path, "rb") as f:
+            h.update(f.read())
+    return h.hexdigest()[:16]
+
+
 def _disk_cache_path(file_path: str, include_comments: bool) -> Optional[str]:
     """Get the disk cache file path for a given source file."""
     cache_dir = _get_disk_cache_dir()
     if not cache_dir:
         return None  # pragma: no cover
-    key = f"{file_path}:{include_comments}"
+    key = f"{file_path}:{include_comments}:{_STRICT_COMMAS.get()}:{_ast_format_tag()}"
     h = hashlib.sha256(key.encode()).hexdigest()[:16]
     return os.path.join(cache_dir, f"{h}.pickle")
 
@@ -429,7 +477,7 @@ def _parse_single_file(file_path: str, include_comments: bool = False) -> list[A
         raise FileNotFoundError(f"File {file_path} not found")
 
     current_mtime = os.path.getmtime(file_path)
-    cache_key = (file_path, include_comments)
+    cache_key = (file_path, include_comments, _STRICT_COMMAS.get())
 
     # Check in-memory cache
     if cache_key in _ast_cache:
@@ -450,8 +498,10 @@ def _parse_single_file(file_path: str, include_comments: bool = False) -> list[A
     source_map = SourceMap()
     source_map.add_origin(file_path, code)
 
-    parser = getOpenSCADParser(reduce_tree=False, include_comments=include_comments)
+    parser = getOpenSCADParser(reduce_tree=False)
     ast = parse_ast(parser, code, source_map=source_map)
+    if ast is not None and include_comments:
+        ast = _attach_all_comments(ast, code, file_path)
 
     # Cache in memory and on disk
     _ast_cache[cache_key] = (ast, current_mtime)
@@ -460,14 +510,30 @@ def _parse_single_file(file_path: str, include_comments: bool = False) -> list[A
     return ast
 
 
+def _deps_unchanged(deps: dict[str, float]) -> bool:
+    """Whether every file a resolution read still has the mtime it had."""
+    try:
+        return all(os.path.getmtime(path) == mtime for path, mtime in deps.items())
+    except OSError:  # one was deleted
+        return False
+
+
 def _resolve_includes(ast_nodes: list[ASTNode] | None, current_file: str,
                       include_comments: bool = False,
-                      visited: set | None = None) -> list[ASTNode] | None:
-    """Resolve IncludeStatement nodes by parsing and inlining referenced files."""
+                      open_files: tuple = (),
+                      deps: dict | None = None) -> list[ASTNode] | None:
+    """Resolve IncludeStatement nodes by parsing and inlining referenced files.
+
+    A file is included every time it is named, as OpenSCAD includes it: an
+    `include` written twice runs the file twice. Only a file already open on
+    this include chain (`open_files`; the top-level file is not one) is
+    refused -- OpenSCAD warns that it can't find it and carries on -- which is
+    what stops a cycle. Every file read is recorded in `deps` with its mtime.
+    """
     if ast_nodes is None:
         return None
-    if visited is None:
-        visited = set()
+    if deps is None:
+        deps = {}
 
     result = []
     for node in ast_nodes:
@@ -475,16 +541,14 @@ def _resolve_includes(ast_nodes: list[ASTNode] | None, current_file: str,
             filename = node.filepath.val
             lib_file = findLibraryFile(current_file, filename)
             if lib_file is None:
-                raise FileNotFoundError(
-                    f"Included file '{filename}' not found. "
-                    f"Searched relative to: {current_file if current_file else 'current directory'}"
-                )
+                raise FileNotFoundError(_not_found("Included file", filename, current_file))
             lib_file = os.path.abspath(lib_file)
-            if lib_file in visited:
+            if lib_file in open_files:
                 continue
-            visited.add(lib_file)
+            deps[lib_file] = os.path.getmtime(lib_file)
             included_ast = _parse_single_file(lib_file, include_comments)
-            included_ast = _resolve_includes(included_ast, lib_file, include_comments, visited)
+            included_ast = _resolve_includes(included_ast, lib_file, include_comments,
+                                             open_files + (lib_file,), deps)
             if included_ast:
                 result.extend(included_ast)
         else:
@@ -550,21 +614,22 @@ def getASTfromFile(file: str, include_comments: bool = False, process_includes:
         return _parse_single_file(file_path, include_comments)
 
     # Check resolved cache (in-memory only since resolved ASTs depend on multiple files)
-    resolved_key = (file_path, include_comments, True)
+    resolved_key = (file_path, include_comments, True, _STRICT_COMMAS.get())
     if resolved_key in _resolved_cache:
-        cached_ast, cached_mtime = _resolved_cache[resolved_key]
-        if cached_mtime == current_mtime:
+        cached_ast, cached_deps = _resolved_cache[resolved_key]
+        if _deps_unchanged(cached_deps):
             return cached_ast
 
     # Parse the file independently (uses per-file cache)
     ast = _parse_single_file(file_path, include_comments)
 
     # Resolve all include statements recursively
-    visited = {file_path}
-    ast = _resolve_includes(ast, file_path, include_comments, visited)
+    deps = {file_path: current_mtime}
+    ast = _resolve_includes(ast, file_path, include_comments, (), deps)
 
-    # Cache the resolved result
-    _resolved_cache[resolved_key] = (ast, current_mtime)
+    # Cache the resolved result, valid while every file it read is unchanged:
+    # keyed on the top file alone, an edited include went unnoticed.
+    _resolved_cache[resolved_key] = (ast, deps)
 
     return ast
 
@@ -574,13 +639,9 @@ def getASTfromLibraryFile(currfile: str, libfile: str, include_comments: bool =
     Find and parse an OpenSCAD library file using OpenSCAD's search path rules,
     and return both the AST and absolute path to the file.
 
-    This function searches for the library file in the following order:
-    1. Directory of the current file (if currfile is provided)
-    2. Directories specified in OPENSCADPATH environment variable
-    3. Platform-specific default library directories:
-       - Windows: ~/Documents/OpenSCAD/libraries
-       - macOS: ~/Documents/OpenSCAD/libraries
-       - Linux: ~/.local/share/OpenSCAD/libraries
+    This function searches the directories librarySearchDirs(currfile)
+    returns, in order: the current file's directory, OPENSCADPATH, the
+    platform's libraries folder, then libraries beside this package.
 
     Once found, the file is parsed using getASTfromFile(), which includes
     caching support and include processing.
@@ -624,10 +685,7 @@ def getASTfromLibraryFile(currfile: str, libfile: str, include_comments: bool =
     found_file = findLibraryFile(currfile, libfile)
 
     if found_file is None:
-        raise FileNotFoundError(
-            f"Library file '{libfile}' not found in search paths. "
-            f"Searched in: current file directory, OPENSCADPATH, and platform default paths."
-        )
+        raise FileNotFoundError(_not_found("Library file", libfile, currfile))
 
     # Use getASTfromFile() which includes caching and include processing
     ast = getASTfromFile(found_file, include_comments=include_comments, process_includes=process_includes)

{openscad_parser-2.6.1 → openscad_parser-3.1.0}/src/openscad_parser/ast/builder.py

@@ -984,6 +984,13 @@ class ASTBuilderVisitor(PTNodeVisitor):
     def visit_primary(self, node, children):
         return children[0]
     
+    def visit_render_expr(self, node, children):
+        # Grammar: (KWD_RENDER, TOK_PAREN, arguments, TOK_ENDPAREN, statement_block)
+        arguments = children.get_rule("arguments") or []
+        block = children.get_rule("statement_block") or []
+        return RenderExpression(arguments=list(arguments), children=list(block),
+                                position=self._get_node_position(node))
+
     def visit_range_expr(self, node, children):
         # OpenSCAD syntax: [start:end] or [start:step:end]
         start = children[0]
@@ -993,7 +1000,8 @@ class ASTBuilderVisitor(PTNodeVisitor):
         else:
             end = children[1]
             step = NumberLiteral(val=1.0, position=self._get_node_position(node))
-        return RangeLiteral(start=start, end=end, step=step, position=self._get_node_position(node))
+        return RangeLiteral(start=start, end=end, step=step, implicit_step=len(children) <= 2,
+                            position=self._get_node_position(node))
     
     def visit_vector_expr(self, node, children):
         elements = children if children else []
@@ -1093,8 +1101,14 @@ class ASTBuilderVisitor(PTNodeVisitor):
             position=self._get_node_position(node)
         )
     
+    def _header_assignments(self, children) -> list:
+        """The `(...)` list's assignments only. Filtering `children` for
+        Assignments also took every assignment in a braced body -- `for (i =
+        [0:1]) { a = i; }` made `a` a loop variable."""
+        return list(children.get_rule('assignments_expr') or [])
+
     def visit_modular_for(self, node, children):
-        assignments = [c for c in children if isinstance(c, Assignment)]
+        assignments = self._header_assignments(children)
         body = children.get_rule('child_statement')
         return ModularFor(
             assignments=assignments,
@@ -1103,12 +1117,12 @@ class ASTBuilderVisitor(PTNodeVisitor):
         )
 
     def visit_modular_intersection_for(self, node, children):
-        assignments = [c for c in children if isinstance(c, Assignment)]
+        assignments = self._header_assignments(children)
         body = children.get_rule('child_statement')
         return ModularIntersectionFor(assignments=assignments, body=body, position=self._get_node_position(node))
 
     def visit_modular_let(self, node, children):
-        assignments = [c for c in children if isinstance(c, Assignment)]
+        assignments = self._header_assignments(children)
         mods = children.get_rule('child_statement')
         return ModularLet(assignments=assignments, children=mods, position=self._get_node_position(node))