pyvbaanalysis 2.2.0__tar.gz → 2.2.1__tar.gz

{pyvbaanalysis-2.2.0 → pyvbaanalysis-2.2.1}/CHANGELOG.md

@@ -5,6 +5,74 @@ All notable changes to pyVBAanalysis are recorded here. The format follows
 follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html): a minor version
 per milestone.
 
+## 2.2.1 - 2026-09-23
+
+Sync to XLIDE 10.7.1 (commit 6ead73d), from 10.6.0. Upstream fixed how its
+lexer and parser read a handful of lines the VBE compiles (XLIDE issues #82 to
+#90), and the port takes each fix. XLIDE 10.7.0 changed nothing the port reads.
+
+### Added
+
+* `LoadedModule.designer_block`: the export header a reader stripped ahead of
+  `source`, empty when there was none. `designer_block + source` is the module
+  text as read, so a span in the analyzed body can be placed in the file.
+
+### Changed
+
+* A contextual keyword is a `KEYWORD` token only inside the statement that
+  makes it one: `Text` after `Option Compare`, `Step` in a `For` header,
+  `Output` in an `Open` statement. Elsewhere, as in `Dim text As String`, it is
+  an `IDENTIFIER` (XLIDE issue #86). `PtrSafe` joins these words, as it did
+  upstream with issue #41.
+* A comment ending in ` _` runs on through the next line, so its token can span
+  physical lines (#82). A line continuation may have whitespace after its `_`
+  (#83).
+* `1.` lexes as a float and `&17` as an octal literal. `=>`, `=<` and `><` are
+  one operator token, whose `canonical_text` gives the standard spelling (#87).
+
+### Fixed
+
+False positives 2.2.0 reported on code that compiles, and two errors it missed:
+
+* `unreachable-code` on the line after
+  `If conn Is Nothing Then ACCT = CVErr(xlErrNA): Exit Function`. Every
+  statement a one-line `If` runs after a colon belongs to the If (MS-VBAL
+  5.4.2.9). After a `Set x = Nothing` or an `Erase` there, the next line no
+  longer reports an unset object or an unallocated array. A `Set` inside a
+  one-line `If` no longer leaves the object reported as Nothing after it.
+* Findings on the line after a comment ending in ` _` (#82), and a missing
+  `Then` or a call to a variable on the line after a continuation with spaces
+  after its `_` (#83).
+* `If x Then:` read as a block If (#84), and a one-word `EndIf` read as no
+  closer, so the lines after it reported as unreachable (#88).
+* `invalid-expression-syntax` on `1.`, `&17`, `a => b`, `a < > b` and the other
+  spellings the VBE reads (#87). `s = "a" &1`, which the VBE refuses, is now
+  reported, and `s = "a" &9` is still a concatenation.
+* `argument-count` missed on `Needs, 2`: a comma touching the callee opens its
+  argument list, as the VBE reads it (#85).
+* `assignment-object-type-mismatch` on `Shape.Duplicate` assigned to a `Shape`,
+  on `SparklineGroup.SeriesColor` assigned to a `FormatColor`, and on a
+  `Charts` or `Worksheets` collection assigned to a `Sheets` variable (#90).
+* `Err.LastDllError` is spelled the way the VBE writes it (#89).
+* The command line counted lines in a `.cls` or `.frm` export from the end of
+  its designer header (the `VERSION` line and `Begin ... End` block the reader
+  strips before analysis), so a class module's findings printed four lines
+  early and a UserForm's early by the height of its form block. Lines, and the
+  JSON `start` and `end` offsets, now count the file as saved. Modules read
+  from an Office container are numbered as before, since pyOpenVBA reads them
+  without a designer header. The library's spans still index the code body.
+
+### Verified
+
+* Upstream's own 10.7.1 test suite, recorded and replayed through the port:
+  1081 standalone and 936 project calls, every result identical in code, span
+  and message. Before the port changes 24 of them differed, so the replay sees
+  what this release changes.
+* The oracle corpus (1820 diagnostics), 16 real workbooks, 195 Office files of
+  every host, 693 further projects (948 modules) and 7 VB6 projects: identical
+  diagnostics from both analyzers.
+* Against 2.2.0, the largest module (26,721 lines) takes the same CPU time.
+
 ## 2.2.0 - 2026-09-22
 
 Sync to XLIDE 10.6.0 (commit 5682c8f), from 6.2.0: twelve new diagnostics, early

{pyvbaanalysis-2.2.0 → pyvbaanalysis-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyvbaanalysis
-Version: 2.2.0
+Version: 2.2.1
 Summary: Pure-Python static analysis for Excel VBA
 Project-URL: Homepage, https://github.com/WilliamSmithEdward/pyVBAanalysis
 Project-URL: Repository, https://github.com/WilliamSmithEdward/pyVBAanalysis

{pyvbaanalysis-2.2.0 → pyvbaanalysis-2.2.1}/docs/api-reference.md

@@ -54,6 +54,9 @@ These are re-exported at the package root for convenience:
   `modules`, the `host` its extension implies, and `referenced_hosts`, the other
   Office libraries its project references (`None` when the reference list could
   not be read).
+* A `LoadedModule` carries a module's `name`, `kind`, and `source` (the code body
+  the analyzer reads), plus `designer_block`, the export header the reader stripped
+  ahead of `source` (empty when there was none).
 * Building blocks: `LoadedModule`, `strip_export_header`, `classify_module_kind`,
   `module_name_from_text`, `loaded_module_from_text`, `WorkbookReadError`,
   `LooseFileReadError`, and the extension sets `LOOSE_EXTENSIONS`,

{pyvbaanalysis-2.2.0 → pyvbaanalysis-2.2.1}/docs/usage.md

@@ -136,6 +136,11 @@ analyze_loose_files(["Module1.bas", "Widget.cls"])     # several, as one project
 skipped for it (see "Whole project vs a single file" below). Use `analyze_loose_files`
 to analyze several files together with shared cross-module context.
 
+Spans index the code body the analyzer reads, which starts after the stripped header.
+`load_loose_module` returns a `LoadedModule` whose `designer_block` holds that header,
+so `line_col(module.designer_block + module.source, len(module.designer_block) + span.start)`
+places a span in the file. The command line reports positions this way.
+
 ### Office macro containers
 
 The container reader reads VBA directly out of an Office file via pyOpenVBA (the one
@@ -291,6 +296,12 @@ project), or an Office macro container, whose extension selects the host model.
 `pyvbaanalysis --version` prints the version, and `python -m pyvbaanalysis` is
 equivalent to the `pyvbaanalysis` command.
 
+Each diagnostic is placed by line and column in the module text as read. For a loose
+file that is the file itself, so the `VERSION` and `Begin ... End` header of a `.cls`
+or `.frm` export counts and the numbers match an editor. For an Office container it
+is the module's stored text, which begins at its `Attribute` lines; the VBE hides
+those lines, so its line numbers run lower by their count.
+
 Flags:
 
 | Flag | Effect |
@@ -336,7 +347,8 @@ diagnostics are reported or a file cannot be read, and `2` for a usage error.
 ]
 ```
 
-`start` and `end` are character offsets; `line` and `column` are 1-based.
+`start` and `end` are character offsets and `line` and `column` are 1-based, all in
+the module text as read (see above).
 
 ## Use in CI
 

{pyvbaanalysis-2.2.0 → pyvbaanalysis-2.2.1}/pyvbaanalysis/__init__.py

@@ -41,7 +41,7 @@ from .reader import (
 )
 from .symbols import ModuleInput, ModuleSymbolKind, ProjectIndex, ProjectIndexOptions
 
-__version__ = "2.2.0"
+__version__ = "2.2.1"
 
 __all__ = [
     "AnalyzeModuleOptions",

{pyvbaanalysis-2.2.0 → pyvbaanalysis-2.2.1}/pyvbaanalysis/call/call_context.py

@@ -142,7 +142,10 @@ def bare_call_statement_target(source: str, span: Span) -> BareCallStatementTarg
         after_close = toks[close + 1] if 0 <= close and close + 1 < len(toks) else None
         if after_close is None or after_close.raw_text in (".", "("):
             return None
-    elif not explicit_call:
+    elif not explicit_call and r != ",":
+        # A comma cannot continue the callee, so it opens the argument list with
+        # or without a space: the VBE reads `Needs, 2` as `Needs , 2`, a missing
+        # first argument and 2 (XLIDE issue #85).
         gap = source[span.start + callee.end : span.start + next_tok.start]
         if _WHITESPACE.search(gap) is None:
             return None

{pyvbaanalysis-2.2.0 → pyvbaanalysis-2.2.1}/pyvbaanalysis/cli.py

@@ -33,6 +33,7 @@ from .project import analyze_project
 from .reader import (
     LOOSE_EXTENSIONS,
     OFFICE_EXTENSIONS,
+    LoadedModule,
     LooseFileReadError,
     WorkbookReadError,
     load_loose_module,
@@ -137,8 +138,7 @@ def _analyze_loose_group(
         whole_project=whole_project,
         inline_suppression=inline_suppression,
     )
-    sources = {m.name: m.source for m in unique}
-    return [_ProjectResult("(loose files)", diagnostics, sources)], warnings, errors
+    return [_ProjectResult("(loose files)", diagnostics, unique)], warnings, errors
 
 
 def _analyze_workbook_group(
@@ -167,8 +167,7 @@ def _analyze_workbook_group(
             host=project.host,
             referenced_hosts=project.referenced_hosts,
         )
-        sources = {m.name: m.source for m in modules}
-        results.append(_ProjectResult(str(path), diagnostics, sources))
+        results.append(_ProjectResult(str(path), diagnostics, modules))
     return results, errors
 
 
@@ -179,11 +178,23 @@ class _ProjectResult:
         self,
         label: str,
         diagnostics: dict[str, list[VbaDiagnostic]],
-        sources: dict[str, str],
+        modules: Sequence[LoadedModule],
     ) -> None:
         self.label = label
         self.diagnostics = diagnostics
-        self.sources = sources
+        self.modules = {module.name: module for module in modules}
+
+
+def _text_as_read(module: LoadedModule | None) -> tuple[str, int]:
+    """A module's text as read, and where the body the analyzer saw starts in it.
+
+    The reader strips a .cls or .frm export's designer block before analysis, so a
+    span indexes the body; shifting it by the block's length places it in the file
+    as saved, which is where a user will look for it.
+    """
+    if module is None:
+        return "", 0
+    return module.designer_block + module.source, len(module.designer_block)
 
 
 def _render_text(results: Sequence[_ProjectResult]) -> str:
@@ -195,10 +206,10 @@ def _render_text(results: Sequence[_ProjectResult]) -> str:
             if not diagnostics:
                 continue
             any_in_project = True
-            source = result.sources.get(module_name, "")
+            text, shift = _text_as_read(result.modules.get(module_name))
             lines.append(f"  {module_name}")
             for diag in diagnostics:
-                line, column = line_col(source, diag.span.start)
+                line, column = line_col(text, shift + diag.span.start)
                 lines.append(
                     f"    {line}:{column} {diag.severity.value} {diag.code}  {diag.message}"
                 )
@@ -207,28 +218,31 @@ def _render_text(results: Sequence[_ProjectResult]) -> str:
     return "\n".join(lines)
 
 
+def _diagnostic_json(diag: VbaDiagnostic, text: str, shift: int) -> dict[str, object]:
+    start = shift + diag.span.start
+    line, column = line_col(text, start)
+    return {
+        "code": diag.code,
+        "severity": diag.severity.value,
+        "message": diag.message,
+        "start": start,
+        "end": shift + diag.span.end,
+        "line": line,
+        "column": column,
+        "spec_reference": diag.spec_reference,
+    }
+
+
 def _render_json(results: Sequence[_ProjectResult]) -> str:
     payload = []
     for result in results:
         modules = []
         for module_name, diagnostics in result.diagnostics.items():
-            source = result.sources.get(module_name, "")
+            text, shift = _text_as_read(result.modules.get(module_name))
             modules.append(
                 {
                     "module": module_name,
-                    "diagnostics": [
-                        {
-                            "code": diag.code,
-                            "severity": diag.severity.value,
-                            "message": diag.message,
-                            "start": diag.span.start,
-                            "end": diag.span.end,
-                            "line": line_col(source, diag.span.start)[0],
-                            "column": line_col(source, diag.span.start)[1],
-                            "spec_reference": diag.spec_reference,
-                        }
-                        for diag in diagnostics
-                    ],
+                    "diagnostics": [_diagnostic_json(diag, text, shift) for diag in diagnostics],
                 }
             )
         payload.append({"project": result.label, "modules": modules})

{pyvbaanalysis-2.2.0 → pyvbaanalysis-2.2.1}/pyvbaanalysis/conditional/conditional_compilation.py

@@ -16,7 +16,7 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Union
 
-from ..lexer.token_helpers import token_word
+from ..lexer.token_helpers import relational_operator_at, token_word
 from ..lexer.token_kinds import TokenKind, VbaToken
 from ..lexer.tokenize import tokenize
 from ..parser.nodes import (
@@ -593,14 +593,15 @@ class _ConditionalExpressionParser:
 
     def _parse_comparison(self) -> ConditionalValue | None:
         left = self._parse_unary()
-        op_token = self._peek()
-        op = op_token.raw_text if op_token is not None else None
         # Relational operators (<, >, <=, >=) join the existing equality (=, <>)
-        # handling so `#If Win64 >= 1 Then` and friends evaluate. Anything else
-        # (Like, etc.) is left to the caller as an unmodeled remainder.
-        if op not in ("=", "<>", "<", ">", "<=", ">="):
+        # handling so `#If Win64 >= 1 Then` and friends evaluate, in any of the
+        # spellings MS-VBAL 5.6.9.5 allows (`=>`, `< >`). Anything else (Like,
+        # etc.) is left to the caller as an unmodeled remainder.
+        relational = relational_operator_at(self._tokens, self._index)
+        if relational is None:
             return left
-        self._index += 1
+        op, length = relational
+        self._index += length
         right = self._parse_unary()
         if left is None or right is None:
             return None