CG-9706: Support imp.is_dynamic

src/codegen/sdk/core/import_resolution.py

@@ -81,6 +81,8 @@ class Import(Usable[ImportStatement], Chainable, Generic[TSourceFile]):
     import_type: ImportType
     import_statement: ImportStatement
 
+    dynamic_import_parent_types = set()
+
     def __init__(
         self,
         ts_node: TSNode,
@@ -381,6 +383,49 @@ def imported_exports(self) -> list[Exportable]:
                 For symbol imports, contains only the single imported symbol.
         """
 
+    @property
+    def is_dynamic(self) -> bool:
+        """Determines if this import is dynamically loaded based on its parent symbol.
+
+        A dynamic import is one that appears within control flow or scope-defining statements, such as:
+        - Inside function definitions
+        - Inside class definitions
+        - Inside if/else blocks
+        - Inside try/except blocks
+        - Inside with statements
+
+        Dynamic imports are only loaded when their containing block is executed, unlike
+        top-level imports which are loaded when the module is imported.
+
+        Examples:
+            Dynamic imports:
+            ```python
+            def my_function():
+                import foo  # Dynamic - only imported when function runs
+
+            if condition:
+                from bar import baz  # Dynamic - only imported if condition is True
+
+            with context():
+                import qux  # Dynamic - only imported within context
+            ```
+
+            Static imports:
+            ```python
+            import foo  # Static - imported when module loads
+            from bar import baz  # Static - imported when module loads
+            ```
+
+        Returns:
+            bool: True if the import is dynamic (within a control flow or scope block),
+            False if it's a top-level import.
+        """
+        if not (self.ts_node.parent.parent):
+            return False
+
+        is_dynamic = self.ts_node.parent.parent.type in self.dynamic_import_parent_types
+        return is_dynamic
+
     ####################################################################################################################
     # MANIPULATIONS
     ####################################################################################################################

src/codegen/sdk/python/import_resolution.py

@@ -28,6 +28,8 @@
 class PyImport(Import["PyFile"]):
     """Extends Import for Python codebases."""
 
+    dynamic_import_parent_types = {"with_statement", "function_definition", "class_definition", "if_statement", "try_statement", "else_clause"}
+
     @reader
     def is_module_import(self) -> bool:
         """Determines if the import is a module-level or wildcard import.

src/codegen/sdk/typescript/import_resolution.py

@@ -30,6 +30,8 @@
 class TSImport(Import["TSFile"], Exportable):
     """Extends Import for TypeScript codebases."""
 
+    dynamic_import_parent_types = {"function_declaration", "method_definition", "arrow_function", "if_statement", "try_statement", "else_clause"}
+
     @reader
     def is_type_import(self) -> bool:
         """Checks if an import is a type import.

tests/unit/codegen/sdk/code_generation/test_api_doc_generation.py

@@ -40,7 +40,7 @@ def test_api_doc_generation_sanity(codebase, language: ProgrammingLanguage) -> N
     other_lang = "TS" if language == ProgrammingLanguage.PYTHON else "Py"
     # =====[ Python ]=====
     docs = get_codegen_sdk_docs(language=language, codebase=codebase)
-    assert count_tokens(docs) < 50500
+    assert count_tokens(docs) < 50700
     assert f"{lang}Function" in docs
     assert f"{lang}Class" in docs
     assert f"{other_lang}Function" not in docs

tests/unit/codegen/sdk/python/import_resolution/test_is_dynamic.py

@@ -0,0 +1,125 @@
+from codegen.sdk.codebase.factory.get_session import get_codebase_session
+from codegen.sdk.enums import ProgrammingLanguage
+
+
+def test_py_import_is_dynamic_in_function(tmpdir):
+    # language=python
+    content = """
+    def my_function():
+        import foo  # Dynamic import inside function
+        from bar import baz  # Another dynamic import
+
+    import static_import  # Static import at module level
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.py": content}, programming_language=ProgrammingLanguage.PYTHON) as codebase:
+        file = codebase.get_file("test.py")
+        imports = file.imports
+
+        # Dynamic imports inside function
+        assert imports[0].is_dynamic  # import foo
+        assert imports[1].is_dynamic  # from bar import baz
+
+        # Static import at module level
+        assert not imports[2].is_dynamic  # import static_import
+
+
+def test_py_import_is_dynamic_in_if_block(tmpdir):
+    # language=python
+    content = """
+    import top_level  # Static import
+
+    if condition:
+        import conditional  # Dynamic import in if block
+        from x import y    # Another dynamic import
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.py": content}, programming_language=ProgrammingLanguage.PYTHON) as codebase:
+        file = codebase.get_file("test.py")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # top_level import
+        assert imports[1].is_dynamic  # conditional import
+        assert imports[2].is_dynamic  # from x import y
+
+
+def test_py_import_is_dynamic_in_try_except(tmpdir):
+    # language=python
+    content = """
+    import static_first  # Static import
+
+    try:
+        import dynamic_in_try  # Dynamic import in try block
+        from x.y import z     # Another dynamic import
+    except ImportError:
+        pass
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.py": content}, programming_language=ProgrammingLanguage.PYTHON) as codebase:
+        file = codebase.get_file("test.py")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static_first import
+        assert imports[1].is_dynamic  # dynamic_in_try import
+        assert imports[2].is_dynamic  # from x.y import z
+
+
+def test_py_import_is_dynamic_in_with_block(tmpdir):
+    # language=python
+    content = """
+    import static_import  # Static import
+
+    with context_manager():
+        import dynamic_in_with  # Dynamic import in with block
+        from a.b import c      # Another dynamic import
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.py": content}, programming_language=ProgrammingLanguage.PYTHON) as codebase:
+        file = codebase.get_file("test.py")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static_import
+        assert imports[1].is_dynamic  # dynamic_in_with import
+        assert imports[2].is_dynamic  # from a.b import c
+
+
+def test_py_import_is_dynamic_in_class_method(tmpdir):
+    # language=python
+    content = """
+    import static_import  # Static import
+
+    class MyClass:
+        def my_method(self):
+            import dynamic_in_method  # Dynamic import in method
+            from pkg import module    # Another dynamic import
+
+        @classmethod
+        def class_method(cls):
+            import another_dynamic    # Dynamic import in classmethod
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.py": content}, programming_language=ProgrammingLanguage.PYTHON) as codebase:
+        file = codebase.get_file("test.py")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static_import
+        assert imports[1].is_dynamic  # dynamic_in_method import
+        assert imports[2].is_dynamic  # from pkg import module
+        assert imports[3].is_dynamic  # another_dynamic import
+
+
+def test_py_import_is_dynamic_in_nested_function(tmpdir):
+    # language=python
+    content = """
+    import static_import  # Static import
+
+    def outer_function():
+        import dynamic_in_outer  # Dynamic import in outer function
+
+        def inner_function():
+            import dynamic_in_inner  # Dynamic import in inner function
+            from x import y         # Another dynamic import
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.py": content}, programming_language=ProgrammingLanguage.PYTHON) as codebase:
+        file = codebase.get_file("test.py")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static_import
+        assert imports[1].is_dynamic  # dynamic_in_outer import
+        assert imports[2].is_dynamic  # dynamic_in_inner import
+        assert imports[3].is_dynamic  # from x import y

tests/unit/codegen/sdk/typescript/import_resolution/test_is_dynamic.py

@@ -0,0 +1,112 @@
+from codegen.sdk.codebase.factory.get_session import get_codebase_session
+from codegen.sdk.enums import ProgrammingLanguage
+
+
+def test_ts_import_is_dynamic_in_function_declaration(tmpdir):
+    # language=typescript
+    content = """
+    import { staticImport } from './static';
+
+    function loadModule() {
+        import('./dynamic').then(module => {
+            console.log(module);
+        });
+    }
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.ts": content}, programming_language=ProgrammingLanguage.TYPESCRIPT) as codebase:
+        file = codebase.get_file("test.ts")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static import
+        assert imports[1].is_dynamic  # dynamic import in function
+
+
+def test_ts_import_is_dynamic_in_method_definition(tmpdir):
+    # language=typescript
+    content = """
+    import { Component } from '@angular/core';
+
+    class MyComponent {
+        async loadFeature() {
+            const feature = await import('./feature');
+        }
+
+        @Decorator()
+        async decoratedMethod() {
+            const module = await import('./decorated');
+        }
+    }
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.ts": content}, programming_language=ProgrammingLanguage.TYPESCRIPT) as codebase:
+        file = codebase.get_file("test.ts")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static import
+        assert imports[1].is_dynamic  # dynamic import in method
+        assert imports[2].is_dynamic  # dynamic import in decorated method
+
+
+def test_ts_import_is_dynamic_in_arrow_function(tmpdir):
+    # language=typescript
+    content = """
+    import { useState } from 'react';
+
+    const MyComponent = () => {
+        const loadModule = async () => {
+            const module = await import('./lazy');
+        };
+
+        return <button onClick={loadModule} />;
+    };
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.ts": content}, programming_language=ProgrammingLanguage.TYPESCRIPT) as codebase:
+        file = codebase.get_file("test.ts")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static import
+        assert imports[1].is_dynamic  # dynamic import in async arrow function
+
+
+def test_ts_import_is_dynamic_in_if_statement(tmpdir):
+    # language=typescript
+    content = """
+    import { isFeatureEnabled } from './utils';
+
+    if (isFeatureEnabled('feature')) {
+        import('./feature').then(module => {
+            module.enableFeature();
+        });
+    } else {
+        import('./fallback').then(module => {
+            module.useFallback();
+        });
+    }
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.ts": content}, programming_language=ProgrammingLanguage.TYPESCRIPT) as codebase:
+        file = codebase.get_file("test.ts")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static import
+        assert imports[1].is_dynamic  # dynamic import in if block
+        assert imports[2].is_dynamic  # dynamic import in else block
+
+
+def test_ts_import_is_dynamic_in_try_statement(tmpdir):
+    # language=typescript
+    content = """
+    import { logger } from './logger';
+
+    try {
+        const module = await import('./main');
+    } catch (error) {
+        const fallback = "hello"
+    } finally {
+        const cleanup = "hello"
+    }
+    """
+    with get_codebase_session(tmpdir=tmpdir, files={"test.ts": content}, programming_language=ProgrammingLanguage.TYPESCRIPT) as codebase:
+        file = codebase.get_file("test.ts")
+        imports = file.imports
+
+        assert not imports[0].is_dynamic  # static import
+        assert imports[1].is_dynamic  # dynamic import in try block