openscad-parser 2.6.0__tar.gz → 3.0.1__tar.gz

{openscad_parser-2.6.0 → openscad_parser-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_parser
-Version: 2.6.0
+Version: 3.0.1
 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.0 → openscad_parser-3.0.1}/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.0 → openscad_parser-3.0.1}/pyproject.toml

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

{openscad_parser-2.6.0 → openscad_parser-3.0.1}/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 ---

{openscad_parser-2.6.0 → openscad_parser-3.0.1}/src/openscad_parser/ast/__init__.py

@@ -1,10 +1,13 @@
+import functools
 import hashlib
+import json
 import os
 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 .source_map import SourceMap, process_includes as process_includes_func
 
 # Import all AST nodes from nodes
@@ -53,6 +56,7 @@ from .nodes import (
     LessThanOrEqualOp,
     FunctionLiteral,
     PrimaryCall,
+    RenderExpression,
     PrimaryIndex,
     PrimaryMember,
     VectorElement,
@@ -86,7 +90,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
@@ -104,57 +108,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
 
@@ -256,14 +285,15 @@ def getASTfromString(code: str, include_comments: bool = False, origin: str = "<
 
 
 # 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, float]] = {}
 
 
 def _get_disk_cache_dir() -> Optional[str]:
@@ -284,12 +314,26 @@ 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")):
+        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")
 
@@ -310,17 +354,83 @@ def _load_from_disk_cache(file_path: str, include_comments: bool, current_mtime:
 
 
 def _save_to_disk_cache(file_path: str, include_comments: bool, mtime: float, ast: list[ASTNode] | None):
-    """Save a file's AST to disk cache."""
+    """Save a file's AST to disk cache and update the manifest."""
     cache_path = _disk_cache_path(file_path, include_comments)
     if not cache_path:
         return  # pragma: no cover
     try:
         with open(cache_path, 'wb') as f:
             pickle.dump((mtime, ast), f, protocol=pickle.HIGHEST_PROTOCOL)
+    except OSError:  # pragma: no cover
+        return
+    cache_fname = os.path.basename(cache_path)
+    _manifest_update(cache_fname, file_path)
+    _evict_stale_cache()
+
+
+def _manifest_path() -> Optional[str]:
+    """Get the path to the cache manifest file."""
+    cache_dir = _get_disk_cache_dir()
+    if not cache_dir:
+        return None  # pragma: no cover
+    return os.path.join(cache_dir, "manifest.json")
+
+
+def _manifest_load() -> dict[str, str]:
+    """Load the manifest: {cache_filename: source_file_path}."""
+    path = _manifest_path()
+    if not path or not os.path.exists(path):
+        return {}
+    try:
+        with open(path, 'r') as f:
+            return json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _manifest_save(manifest: dict[str, str]):
+    """Save the manifest to disk."""
+    path = _manifest_path()
+    if not path:
+        return  # pragma: no cover
+    try:
+        with open(path, 'w') as f:
+            json.dump(manifest, f)
     except OSError:  # pragma: no cover
         pass
 
 
+def _manifest_update(cache_fname: str, source_path: str):
+    """Add or update an entry in the manifest."""
+    manifest = _manifest_load()
+    manifest[cache_fname] = source_path
+    _manifest_save(manifest)
+
+
+def _evict_stale_cache():
+    """Remove cache entries whose source files no longer exist."""
+    cache_dir = _get_disk_cache_dir()
+    if not cache_dir:
+        return  # pragma: no cover
+    manifest = _manifest_load()
+    if not manifest:
+        return
+    stale_keys = [
+        fname for fname, source_path in manifest.items()
+        if not os.path.exists(source_path)
+    ]
+    if not stale_keys:
+        return
+    for fname in stale_keys:
+        cache_file = os.path.join(cache_dir, fname)
+        try:
+            os.remove(cache_file)
+        except OSError:
+            pass
+        del manifest[fname]
+    _manifest_save(manifest)
+
+
 def clear_ast_cache():
     """Clear the in-memory AST cache.
 
@@ -346,7 +456,7 @@ def clear_disk_cache():
     cache_dir = _get_disk_cache_dir()
     if cache_dir and os.path.isdir(cache_dir):
         for fname in os.listdir(cache_dir):
-            if fname.endswith('.pickle'):
+            if fname.endswith('.pickle') or fname == 'manifest.json':
                 try:
                     os.remove(os.path.join(cache_dir, fname))
                 except OSError:  # pragma: no cover
@@ -362,7 +472,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:
@@ -408,10 +518,7 @@ 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:
                 continue
@@ -483,7 +590,7 @@ 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:
@@ -507,13 +614,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.
@@ -557,10 +660,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.0 → openscad_parser-3.0.1}/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 []