vue3-migration 1.1.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue3-migration",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Automatically migrate Vue 2 mixins to Vue 3 composables — data, computed, methods, watchers, lifecycle hooks, and all",
   "bin": {
     "vue3-migration": "./bin/cli.js"

package/vue3_migration/core/mixin_analyzer.py

@@ -4,7 +4,7 @@ Mixin analysis — extract members and lifecycle hooks from Vue mixin source cod
 
 import re
 
-from .js_parser import extract_brace_block, extract_property_names
+from .js_parser import extract_brace_block, extract_property_names, skip_non_code
 
 VUE_LIFECYCLE_HOOKS = [
     "beforeCreate", "created", "beforeMount", "mounted",
@@ -46,6 +46,103 @@ def extract_mixin_members(source: str) -> dict[str, list[str]]:
     return members
 
 
+def find_external_this_refs(
+    code: str, own_member_names: list[str]
+) -> list[str]:
+    """Find ``this.X`` references where X is NOT a member of the mixin itself.
+
+    Skips:
+    - Members in *own_member_names* (data, computed, methods, watch of this mixin)
+    - ``this.$xxx`` references (handled by the ``this.$`` warning system)
+    - Matches inside strings, comments, and template literals
+
+    Returns a deduplicated list of external member names.
+    """
+    own_set = set(own_member_names)
+    pattern = re.compile(r"\bthis\.(\w+)")
+    seen: list[str] = []
+    pos = 0
+    while pos < len(code):
+        new_pos, skipped = skip_non_code(code, pos)
+        if skipped:
+            pos = new_pos
+            continue
+        m = pattern.match(code, pos)
+        if m:
+            name = m.group(1)
+            if name not in own_set and not name.startswith("$") and name not in seen:
+                seen.append(name)
+            pos = m.end()
+        else:
+            pos += 1
+    return seen
+
+
+def resolve_external_dep_sources(
+    external_deps: list[str],
+    sibling_entries: list,
+    component_own_members: set[str],
+    component_name: str,
+    component_members_by_section: dict[str, list[str]] | None = None,
+) -> dict[str, dict]:
+    """Resolve where each external dependency comes from.
+
+    For each dep, checks sibling mixin entries and the component's own members.
+    Returns a dict mapping dep name to source info::
+
+        {
+            "entityId": {
+                "kind": "component",  # or "sibling", "ambiguous", "unknown"
+                "detail": "TaskDetailView.data",
+                "sources": ["TaskDetailView.data"],
+            }
+        }
+
+    Args:
+        external_deps: Names of external ``this.X`` references.
+        sibling_entries: Other MixinEntry objects for the same component.
+        component_own_members: Members the component defines itself.
+        component_name: Component file stem (for display in warnings).
+        component_members_by_section: Optional categorized component members
+            (keys: data, computed, methods, watch) for more detailed source info.
+    """
+    result: dict[str, dict] = {}
+    for dep in external_deps:
+        sources: list[str] = []
+
+        # Check sibling mixin entries
+        for sibling in sibling_entries:
+            for section in ("data", "computed", "methods", "watch"):
+                section_members = getattr(sibling.members, section, [])
+                if dep in section_members:
+                    sources.append(f"{sibling.mixin_stem}.{section}")
+                    break  # one hit per sibling is enough
+
+        # Check component's own members (with section detail if available)
+        if dep in component_own_members:
+            comp_section = None
+            if component_members_by_section:
+                for section in ("data", "computed", "methods", "watch"):
+                    if dep in component_members_by_section.get(section, []):
+                        comp_section = section
+                        break
+            if comp_section:
+                sources.append(f"{component_name}.{comp_section}")
+            else:
+                sources.append(f"{component_name}")
+
+        if len(sources) == 0:
+            result[dep] = {"kind": "unknown", "detail": None, "sources": []}
+        elif len(sources) == 1:
+            src = sources[0]
+            kind = "component" if src.startswith(component_name) else "sibling"
+            result[dep] = {"kind": kind, "detail": src, "sources": sources}
+        else:
+            result[dep] = {"kind": "ambiguous", "detail": None, "sources": sources}
+
+    return result
+
+
 def extract_lifecycle_hooks(source: str) -> list[str]:
     """Find Vue lifecycle hooks defined in the mixin source."""
     return [

package/vue3_migration/core/warning_collector.py

@@ -163,6 +163,9 @@ def collect_mixin_warnings(
                 severity="warning",
             ))
 
+    # External dependencies (this.X where X is not in this mixin)
+    warnings.extend(detect_external_dependencies(mixin_source, mixin_members))
+
     # this-aliasing (const self = this)
     warnings.extend(detect_this_aliasing(mixin_source, ""))
 
@@ -175,6 +178,47 @@ def collect_mixin_warnings(
     return warnings
 
 
+def detect_external_dependencies(
+    mixin_source: str,
+    mixin_members: MixinMembers,
+) -> list[MigrationWarning]:
+    """Detect ``this.X`` references where X is not defined in the mixin.
+
+    These are external dependencies — members that come from the component
+    or a sibling mixin via shared ``this`` context. They break in composables
+    because composables are isolated functions without ``this``.
+    """
+    from .mixin_analyzer import find_external_this_refs
+
+    external = find_external_this_refs(mixin_source, mixin_members.all_names)
+    warnings: list[MigrationWarning] = []
+
+    for name in external:
+        # Find the first line containing this.<name> for line_hint
+        match = re.search(rf"\bthis\.{re.escape(name)}\b", mixin_source)
+        line_hint = None
+        if match:
+            line_start = mixin_source.rfind("\n", 0, match.start()) + 1
+            line_end = mixin_source.find("\n", match.end())
+            if line_end == -1:
+                line_end = len(mixin_source)
+            line_hint = mixin_source[line_start:line_end].strip()
+
+        warnings.append(MigrationWarning(
+            mixin_stem="",
+            category="external-dependency",
+            message=(
+                f"'{name}' — external dep, not available in composable scope.\n"
+                f"// Accept as composable param: this.{name} → {name}.value or {name}."
+            ),
+            action_required=f"Accept '{name}' as a composable parameter and rewrite this.{name}",
+            line_hint=line_hint,
+            severity="error",
+        ))
+
+    return warnings
+
+
 def detect_this_aliasing(
     mixin_source: str, mixin_stem: str
 ) -> list[MigrationWarning]:
@@ -255,14 +299,20 @@ def inject_inline_warnings(
     For each warning with a line_hint, inserts ``// ⚠ MIGRATION: {message}``
     above the first line that contains the hint text.
 
+    Warnings that cannot be placed inline (no line_hint or no matching line)
+    are collected and inserted as a block after the confidence header.
+
     Optionally prepends a confidence header comment at the top.
     """
     if confidence is not None:
         header = f"// Migration confidence: {confidence.value} ({warning_count} warnings — see migration report)\n"
         source = header + source
 
+    unplaced: list[MigrationWarning] = []
+
     for w in warnings:
         if not w.line_hint:
+            unplaced.append(w)
             continue
         # Find a line containing the hint text
         lines = source.splitlines(keepends=True)
@@ -276,6 +326,20 @@ def inject_inline_warnings(
             new_lines.append(line)
         if injected:
             source = "".join(new_lines)
+        else:
+            unplaced.append(w)
+
+    # Place unmatched warnings as a block after the confidence header
+    if unplaced:
+        block = "".join(
+            f"// ⚠ MIGRATION: {w.message}\n" for w in unplaced
+        )
+        if confidence is not None:
+            # Insert right after the first line (confidence header)
+            idx = source.index('\n') + 1
+            source = source[:idx] + block + source[idx:]
+        else:
+            source = block + source
 
     return source
 

package/vue3_migration/models.py

@@ -141,6 +141,8 @@ class MixinEntry:
     """Current migration status."""
     warnings: list[MigrationWarning] = field(default_factory=list)
     """Migration warnings detected during analysis and generation."""
+    external_deps: list[str] = field(default_factory=list)
+    """External this.X references not defined in this mixin."""
 
     def compute_status(self) -> MigrationStatus:
         """Determine the migration status based on analysis results."""

package/vue3_migration/workflows/auto_migrate_workflow.py

@@ -14,7 +14,10 @@ from ..core.composable_analyzer import (
 )
 from ..core.composable_search import find_composable_dirs, search_for_composable
 from ..core.file_resolver import compute_import_path, resolve_import_path
-from ..core.mixin_analyzer import extract_lifecycle_hooks, extract_mixin_members
+from ..core.mixin_analyzer import (
+    extract_lifecycle_hooks, extract_mixin_members,
+    find_external_this_refs, resolve_external_dep_sources,
+)
 from ..core.warning_collector import collect_mixin_warnings
 from ..models import (
     ComposableCoverage, FileChange, MigrationConfig, MigrationPlan, MigrationStatus,
@@ -54,6 +57,8 @@ def _analyze_mixin_silent(
     hooks = extract_lifecycle_hooks(mixin_source)
     used = find_used_members(component_source, members.all_names)
 
+    ext_deps = find_external_this_refs(mixin_source, members.all_names)
+
     entry = MixinEntry(
         local_name=local_name,
         mixin_path=mixin_file,
@@ -61,6 +66,7 @@ def _analyze_mixin_silent(
         members=members,
         lifecycle_hooks=hooks,
         used_members=used,
+        external_deps=ext_deps,
     )
 
     if not used:
@@ -241,6 +247,86 @@ def plan_new_composables(
     return changes
 
 
+def _inject_setup_external_dep_warnings(
+    lines: list[str],
+    entry: "MixinEntry",
+    all_entries: list["MixinEntry"],
+    own_members: set[str],
+    component_name: str,
+    indent: str,
+    component_members_by_section: dict[str, list[str]] | None = None,
+) -> list[str]:
+    """Scan lifecycle lines for remaining ``this.X`` and prepend source-resolved warnings.
+
+    Only processes non-``$`` references that survived ``rewrite_this_refs``
+    (i.e. external deps not defined in the current mixin).
+    """
+    if not lines:
+        return lines
+
+    all_text = "\n".join(lines)
+    external_names: list[str] = []
+    for m in re.finditer(r"\bthis\.(\w+)", all_text):
+        name = m.group(1)
+        if not name.startswith("$") and name not in external_names:
+            external_names.append(name)
+
+    if not external_names:
+        return lines
+
+    siblings = [e for e in all_entries if e is not entry]
+    sources = resolve_external_dep_sources(
+        external_names, siblings, own_members, component_name,
+        component_members_by_section=component_members_by_section,
+    )
+
+    result: list[str] = []
+    warned: set[str] = set()
+    for line in lines:
+        for m in re.finditer(r"\bthis\.(\w+)", line):
+            name = m.group(1)
+            if name.startswith("$") or name in warned:
+                continue
+            warned.add(name)
+            src = sources.get(name, {"kind": "unknown", "detail": None, "sources": []})
+            result.extend(
+                _format_setup_warning(name, src, entry, indent)
+            )
+        result.append(line)
+    return result
+
+
+def _format_setup_warning(
+    name: str, src: dict, entry: "MixinEntry", indent: str
+) -> list[str]:
+    """Format a source-resolved warning comment for a setup() external dep."""
+    if src["kind"] == "sibling":
+        detail = src["detail"]  # e.g. "loadingMixin.data"
+        sibling_stem = detail.split(".")[0]
+        sibling_composable = mixin_stem_to_composable_name(sibling_stem)
+        return [
+            f"{indent}// ⚠ MIGRATION: '{name}' — external dep (source: {detail} → {sibling_composable}).",
+            f"{indent}// this.{name} is unavailable in setup(). Use return value from {sibling_composable}() instead.",
+        ]
+    elif src["kind"] == "component":
+        detail = src["detail"]
+        return [
+            f"{indent}// ⚠ MIGRATION: '{name}' — external dep (source: {detail}).",
+            f"{indent}// this.{name} is unavailable in setup(). Replace with local ref.",
+        ]
+    elif src["kind"] == "ambiguous":
+        sources_str = ", ".join(src["sources"])
+        return [
+            f"{indent}// ⚠ MIGRATION: '{name}' — external dep (sources: {sources_str}).",
+            f"{indent}// Ambiguous origin — verify correct source before replacing this.{name}.",
+        ]
+    else:
+        return [
+            f"{indent}// ⚠ MIGRATION: '{name}' — external dep, source not found in component or sibling mixins.",
+            f"{indent}// May come from props, inject, or a parent component. Replace this.{name} manually.",
+        ]
+
+
 def plan_component_injections(
     entries_by_component: list[tuple[Path, list[MixinEntry]]],
     composable_patches: list[FileChange],
@@ -269,6 +355,7 @@ def plan_component_injections(
         # R-7: normalize CRLF
         comp_source = comp_path.read_text(errors="ignore").replace('\r\n', '\n').replace('\r', '\n')
         own_members = extract_own_members(comp_source)
+        comp_members_by_section = extract_mixin_members(comp_source)
         ready_entries = []
 
         for entry in entries:
@@ -377,6 +464,19 @@ def plan_component_injections(
                     mixin_content, entry.lifecycle_hooks, ref_m, plain_m,
                     config.indent + config.indent,  # double indent to match setup() body level
                 )
+
+                # Inject source-resolved warnings for external deps in lifecycle code
+                comp_name = comp_path.stem
+                setup_indent = config.indent + config.indent
+                inline = _inject_setup_external_dep_warnings(
+                    inline, entry, entries, own_members, comp_name, setup_indent,
+                    component_members_by_section=comp_members_by_section,
+                )
+                wrapped = _inject_setup_external_dep_warnings(
+                    wrapped, entry, entries, own_members, comp_name, setup_indent,
+                    component_members_by_section=comp_members_by_section,
+                )
+
                 all_inline_lines.extend(inline)
                 all_lifecycle_calls.extend(wrapped)