taski 0.4.1 → 0.5.0

data/lib/taski/static_analysis/visitor.rb

@@ -7,17 +7,36 @@ module Taski
     class Visitor < Prism::Visitor
       attr_reader :dependencies
 
-      def initialize(target_task_class, target_method = :run)
+      # @param target_task_class [Class] The task class to analyze
+      # @param target_method [Symbol] The method name to analyze (:run or :impl)
+      # @param methods_to_analyze [Set<Symbol>] Set of method names to analyze (for following calls)
+      def initialize(target_task_class, target_method = :run, methods_to_analyze = nil)
         super()
         @target_task_class = target_task_class
         @target_method = target_method
         @dependencies = Set.new
         @in_target_method = false
         @current_namespace_path = []
+        # Methods to analyze: starts with just the target method, grows as we find calls
+        @methods_to_analyze = methods_to_analyze || Set.new([@target_method])
+        # Track which methods we've already analyzed to prevent infinite loops
+        @analyzed_methods = Set.new
+        # Collect method calls made within analyzed methods (for following)
+        @method_calls_to_follow = Set.new
+        # Store method definitions found in the class for later analysis
+        @class_method_defs = {}
+        # Track if we're in an impl call chain (for Section constant detection)
+        @in_impl_chain = false
       end
 
       def visit_class_node(node)
-        within_namespace(extract_constant_name(node.constant_path)) { super }
+        within_namespace(extract_constant_name(node.constant_path)) do
+          if in_target_class?
+            # First pass: collect all method definitions in the target class
+            collect_method_definitions(node)
+          end
+          super
+        end
       end
 
       def visit_module_node(node)
@@ -25,32 +44,80 @@ module Taski
       end
 
       def visit_def_node(node)
-        if node.name == @target_method && in_target_class?
+        if in_target_class? && should_analyze_method?(node.name)
+          @analyzed_methods.add(node.name)
           @in_target_method = true
+          @current_analyzing_method = node.name
+          # Start impl chain when entering impl method
+          @in_impl_chain = true if node.name == :impl && @target_method == :impl
           super
           @in_target_method = false
+          @current_analyzing_method = nil
         else
           super
         end
       end
 
       def visit_call_node(node)
-        detect_task_dependency(node) if @in_target_method
+        if @in_target_method
+          detect_task_dependency(node)
+          detect_method_call_to_follow(node)
+        end
         super
       end
 
       def visit_constant_read_node(node)
-        detect_return_constant(node) if @in_target_method && @target_method == :impl
+        # For Section.impl, detect constants as impl candidates (static dependencies)
+        detect_impl_candidate(node) if in_impl_method?
         super
       end
 
       def visit_constant_path_node(node)
-        detect_return_constant(node) if @in_target_method && @target_method == :impl
+        # For Section.impl, detect constants as impl candidates (static dependencies)
+        detect_impl_candidate(node) if in_impl_method?
         super
       end
 
+      # After visiting, follow any method calls that need analysis
+      # @in_impl_chain is preserved because methods called from impl should
+      # also detect constants as impl candidates
+      def follow_method_calls
+        new_methods = @method_calls_to_follow - @analyzed_methods
+        return if new_methods.empty?
+
+        # Add new methods to analyze
+        @methods_to_analyze.merge(new_methods)
+        @method_calls_to_follow.clear
+
+        # Re-analyze the class methods
+        # Preserve impl chain context: methods called from impl should continue
+        # detecting constants as impl candidates
+        @class_method_defs.each do |method_name, method_node|
+          next unless new_methods.include?(method_name)
+
+          @analyzed_methods.add(method_name)
+          @in_target_method = true
+          @current_analyzing_method = method_name
+          visit(method_node)
+          @in_target_method = false
+          @current_analyzing_method = nil
+        end
+
+        # Recursively follow any new calls discovered
+        follow_method_calls
+      end
+
       private
 
+      # Collect all method definitions in the target class for later analysis
+      def collect_method_definitions(class_node)
+        class_node.body&.body&.each do |node|
+          if node.is_a?(Prism::DefNode)
+            @class_method_defs[node.name] = node
+          end
+        end
+      end
+
       def within_namespace(name)
         @current_namespace_path.push(name)
         yield
@@ -66,18 +133,40 @@ module Taski
         node.slice
       end
 
-      def detect_task_dependency(node)
-        return unless node.receiver
+      def should_analyze_method?(method_name)
+        @methods_to_analyze.include?(method_name) && !@analyzed_methods.include?(method_name)
+      end
 
-        constant_name = extract_receiver_constant(node.receiver)
-        resolve_and_add_dependency(constant_name) if constant_name
+      def in_impl_method?
+        @in_target_method && @in_impl_chain
       end
 
-      def detect_return_constant(node)
+      # Detect method calls that should be followed (calls to methods in the same class)
+      def detect_method_call_to_follow(node)
+        # Only follow calls without explicit receiver (self.method or just method)
+        return if node.receiver && !self_receiver?(node.receiver)
+
+        method_name = node.name
+        # Mark this method for later analysis if it's defined in the class
+        @method_calls_to_follow.add(method_name) if @class_method_defs.key?(method_name)
+      end
+
+      def self_receiver?(receiver)
+        receiver.is_a?(Prism::SelfNode)
+      end
+
+      def detect_impl_candidate(node)
         constant_name = node.slice
         resolve_and_add_dependency(constant_name)
       end
 
+      def detect_task_dependency(node)
+        return unless node.receiver
+
+        constant_name = extract_receiver_constant(node.receiver)
+        resolve_and_add_dependency(constant_name) if constant_name
+      end
+
       def extract_receiver_constant(receiver)
         case receiver
         when Prism::ConstantReadNode, Prism::ConstantPathNode

data/lib/taski/task.rb

@@ -2,7 +2,6 @@
 
 require_relative "static_analysis/analyzer"
 require_relative "execution/registry"
-require_relative "execution/coordinator"
 require_relative "execution/task_wrapper"
 
 module Taski
@@ -24,11 +23,16 @@ module Taski
       # Each call creates a fresh TaskWrapper instance for re-execution support.
       # Use class methods (e.g., MyTask.result) for cached single execution.
       def new
-        Execution::TaskWrapper.new(
-          super,
-          registry: registry,
-          coordinator: coordinator
+        fresh_registry = Execution::Registry.new
+        task_instance = allocate
+        task_instance.send(:initialize)
+        wrapper = Execution::TaskWrapper.new(
+          task_instance,
+          registry: fresh_registry
         )
+        # Pre-register to prevent Executor from creating a duplicate wrapper
+        fresh_registry.register(self, wrapper)
+        wrapper
       end
 
       def cached_dependencies
@@ -55,87 +59,19 @@ module Taski
         Taski.global_registry
       end
 
-      def coordinator
-        @coordinator ||= Execution::Coordinator.new(
-          registry: registry,
-          analyzer: StaticAnalysis::Analyzer
-        )
-      end
-
       def reset!
         registry.reset!
         Taski.reset_global_registry!
         Taski.reset_context!
-        @coordinator = nil
         @circular_dependency_checked = false
       end
 
       def tree
-        build_tree(self, "", Set.new, false)
+        Execution::TreeProgressDisplay.render_static_tree(self)
       end
 
       private
 
-      # ANSI color codes
-      COLORS = {
-        reset: "\e[0m",
-        task: "\e[32m",      # green
-        section: "\e[34m",   # blue
-        impl: "\e[33m",      # yellow
-        tree: "\e[90m",      # gray
-        name: "\e[1m"        # bold
-      }.freeze
-
-      def build_tree(task_class, prefix, visited, is_impl)
-        type_label = colored_type_label(task_class)
-        impl_prefix = is_impl ? "#{COLORS[:impl]}[impl]#{COLORS[:reset]} " : ""
-        name = "#{COLORS[:name]}#{task_class.name}#{COLORS[:reset]}"
-        result = "#{impl_prefix}#{name} #{type_label}\n"
-        return result if visited.include?(task_class)
-
-        visited.add(task_class)
-        dependencies = task_class.cached_dependencies.to_a
-        is_section = section_class?(task_class)
-
-        dependencies.each_with_index do |dep, index|
-          is_last = (index == dependencies.size - 1)
-          result += format_dependency_branch(dep, prefix, is_last, visited, is_section)
-        end
-
-        result
-      end
-
-      def format_dependency_branch(dep, prefix, is_last, visited, is_impl)
-        connector, extension = tree_connector_chars(is_last)
-        dep_tree = build_tree(dep, "#{prefix}#{extension}", visited, is_impl)
-
-        result = "#{prefix}#{COLORS[:tree]}#{connector}#{COLORS[:reset]}"
-        lines = dep_tree.lines
-        result += lines.first
-        lines.drop(1).each { |line| result += line }
-        result
-      end
-
-      def tree_connector_chars(is_last)
-        if is_last
-          ["└── ", "    "]
-        else
-          ["├── ", "│   "]
-        end
-      end
-
-      def colored_type_label(klass)
-        if section_class?(klass)
-          "#{COLORS[:section]}(Section)#{COLORS[:reset]}"
-        else
-          "#{COLORS[:task]}(Task)#{COLORS[:reset]}"
-        end
-      end
-
-      def section_class?(klass)
-        defined?(Taski::Section) && klass < Taski::Section
-      end
-
       # Use allocate + initialize instead of new to avoid infinite loop
       # since new is overridden to return TaskWrapper
       def cached_wrapper
@@ -144,8 +80,7 @@ module Taski
           task_instance.send(:initialize)
           Execution::TaskWrapper.new(
             task_instance,
-            registry: registry,
-            coordinator: coordinator
+            registry: registry
           )
         end
       end

data/lib/taski/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Taski
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/taski.rb

@@ -5,9 +5,9 @@ require_relative "taski/static_analysis/analyzer"
 require_relative "taski/static_analysis/visitor"
 require_relative "taski/static_analysis/dependency_graph"
 require_relative "taski/execution/registry"
-require_relative "taski/execution/coordinator"
 require_relative "taski/execution/task_wrapper"
-require_relative "taski/execution/parallel_progress_display"
+require_relative "taski/execution/executor"
+require_relative "taski/execution/tree_progress_display"
 require_relative "taski/context"
 require_relative "taski/task"
 require_relative "taski/section"
@@ -59,13 +59,17 @@ module Taski
     @global_registry = nil
   end
 
+  # Progress display is enabled by default (tree-style).
+  # Environment variables:
+  # - TASKI_PROGRESS_DISABLE=1: Disable progress display entirely
+  # - TASKI_FORCE_PROGRESS=1: Force enable even without TTY (for testing)
   def self.progress_display
-    return nil unless progress_enabled?
-    @progress_display ||= Execution::ParallelProgressDisplay.new
+    return nil if progress_disabled?
+    @progress_display ||= Execution::TreeProgressDisplay.new
   end
 
-  def self.progress_enabled?
-    ENV["TASKI_PROGRESS"] == "1" || ENV["TASKI_FORCE_PROGRESS"] == "1"
+  def self.progress_disabled?
+    ENV["TASKI_PROGRESS_DISABLE"] == "1"
   end
 
   def self.reset_progress_display!

data/sig/taski.rbs

@@ -2,7 +2,8 @@ module Taski
   VERSION: String
 
   self.@global_registry: Execution::Registry?
-  self.@progress_display: Execution::ParallelProgressDisplay?
+  self.@progress_display: Execution::TreeProgressDisplay?
+  self.@context: Context?
 
   # Type alias for Task class (singleton type with class methods)
   # This represents a Class that inherits from Taski::Task
@@ -11,9 +12,12 @@ module Taski
   # Module-level methods
   def self.global_registry: () -> Execution::Registry
   def self.reset_global_registry!: () -> void
-  def self.progress_display: () -> Execution::ParallelProgressDisplay?
-  def self.progress_enabled?: () -> bool
+  def self.progress_display: () -> Execution::TreeProgressDisplay?
+  def self.progress_disabled?: () -> bool
   def self.reset_progress_display!: () -> void
+  def self.context: () -> Hash[Symbol, untyped]
+  def self.start_context: (options: Hash[Symbol, untyped], root_task: Class) -> void
+  def self.reset_context!: () -> void
 
   # Custom exceptions
   class TaskAbortException < StandardError
@@ -29,23 +33,25 @@ module Taski
 
   # Context class for execution context management
   class Context
-    self.@monitor: Monitor
-    self.@working_directory: String?
-    self.@started_at: Time?
-    self.@root_task: Class?
-
-    def self.working_directory: () -> String
-    def self.started_at: () -> Time
-    def self.root_task: () -> Class?
-    def self.set_root_task: (Class task) -> void
-    def self.reset!: () -> void
+    @options: Hash[Symbol | String, untyped]
+    @root_task: Class
+    @started_at: Time
+    @working_directory: String
+
+    attr_reader started_at: Time
+    attr_reader working_directory: String
+    attr_reader root_task: Class
+
+    def initialize: (options: Hash[Symbol | String, untyped], root_task: Class) -> void
+    def []: (Symbol | String key) -> untyped
+    def fetch: (Symbol | String key, ?untyped default) ?{ () -> untyped } -> untyped
+    def key?: (Symbol | String key) -> bool
   end
 
   # Main Task class
   class Task
     self.@exported_methods: Array[Symbol]
     self.@dependencies_cache: Set[task_class]?
-    self.@coordinator: Execution::Coordinator?
     self.@circular_dependency_checked: bool
 
     # Class methods
@@ -54,10 +60,9 @@ module Taski
     def self.new: () -> Execution::TaskWrapper
     def self.cached_dependencies: () -> Set[task_class]
     def self.clear_dependency_cache: () -> void
-    def self.run: () -> untyped
-    def self.clean: () -> void
+    def self.run: (?context: Hash[Symbol, untyped]) -> untyped
+    def self.clean: (?context: Hash[Symbol, untyped]) -> void
     def self.registry: () -> Execution::Registry
-    def self.coordinator: () -> Execution::Coordinator
     def self.reset!: () -> void
     def self.tree: () -> String
 
@@ -69,9 +74,6 @@ module Taski
     private
 
     # Private class methods
-    def self.build_tree: (task_class task_class, String prefix, Set[task_class] visited) -> String
-    def self.format_dependency_branch: (task_class dep, String prefix, bool is_last, Set[task_class] visited) -> String
-    def self.tree_connector_chars: (bool is_last) -> [String, String]
     def self.cached_wrapper: () -> Execution::TaskWrapper
     def self.define_instance_reader: (Symbol method_name) -> void
     def self.define_class_accessor: (Symbol method_name) -> void
@@ -119,7 +121,8 @@ module Taski
 
       def initialize: () -> void
       def get_or_create: (Class task_class) { () -> TaskWrapper } -> TaskWrapper
-      def get_task: (Class task_class) -> TaskWrapper
+      def get_task: (Class task_class) -> TaskWrapper?
+      def register: (Class task_class, TaskWrapper wrapper) -> void
       def register_thread: (Thread thread) -> void
       def wait_all: () -> void
       def reset!: () -> void
@@ -128,31 +131,52 @@ module Taski
       def run: (Class task_class, Array[Symbol] exported_methods) -> untyped
     end
 
-    # Coordinator class for dependency management
-    class Coordinator
-      @registry: Registry
-      @analyzer: singleton(StaticAnalysis::Analyzer)
+    # Executor class for parallel task execution (Producer-Consumer pattern)
+    class Executor
+      STATE_PENDING: Symbol
+      STATE_ENQUEUED: Symbol
+      STATE_COMPLETED: Symbol
 
-      def initialize: (registry: Registry, analyzer: singleton(StaticAnalysis::Analyzer)) -> void
-      def start_dependencies: (task_class task_class) -> void
-      def start_clean_dependencies: (task_class task_class) -> void
-      def get_dependencies: (task_class task_class) -> Set[task_class]
+      @registry: Registry
+      @worker_count: Integer
+      @execution_queue: Thread::Queue
+      @completion_queue: Thread::Queue
+      @workers: Array[Thread]
+      @dependencies: Hash[Class, Set[Class]]
+      @task_states: Hash[Class, Symbol]
+      @completed_tasks: Set[Class]
+
+      def self.execute: (Class root_task_class, registry: Registry) -> void
+      def initialize: (registry: Registry, ?worker_count: Integer?) -> void
+      def execute: (Class root_task_class) -> void
 
       private
 
-      def start_thread_with: () { () -> void } -> void
-      def start_dependency_execution: (task_class dep_class) -> void
-      def start_dependency_clean: (task_class dep_class) -> void
+      def default_worker_count: () -> Integer
+      def build_dependency_graph: (Class root_task_class) -> void
+      def enqueue_ready_tasks: () -> void
+      def ready_to_execute?: (Class task_class) -> bool
+      def enqueue_task: (Class task_class) -> void
+      def get_or_create_wrapper: (Class task_class) -> TaskWrapper
+      def start_workers: () -> void
+      def worker_loop: () -> void
+      def execute_task: (Class task_class, TaskWrapper wrapper) -> void
+      def run_main_loop: (Class root_task_class) -> void
+      def no_running_tasks?: () -> bool
+      def handle_completion: (Hash[Symbol, untyped] event) -> void
+      def shutdown_workers: () -> void
+      def debug_log: (String message) -> void
     end
 
     # TaskWrapper class for task execution
     class TaskWrapper
       attr_reader task: Task
       attr_reader result: untyped
+      attr_reader error: StandardError?
+      attr_reader timing: TaskTiming?
 
       @task: Task
       @registry: Registry
-      @coordinator: Coordinator
       @result: untyped
       @clean_result: untyped
       @error: StandardError?
@@ -167,38 +191,38 @@ module Taski
       STATE_RUNNING: Symbol
       STATE_COMPLETED: Symbol
 
-      def initialize: (Task task, registry: Registry, coordinator: Coordinator) -> void
+      def initialize: (Task task, registry: Registry) -> void
+      def state: () -> Symbol
+      def pending?: () -> bool
+      def completed?: () -> bool
       def run: () -> untyped
-      def clean: () -> void
+      def clean: () -> untyped
       def get_exported_value: (Symbol method_name) -> untyped
-      def start_thread_with: () { () -> void } -> void
-      def execute_with_state_pattern: (state_getter: ^() -> Symbol, starter: ^() -> void, waiter: ^() -> void, ?pre_start_check: (^() -> void)?) -> void
-      def execute_task_if_needed: () -> void
-      def start_async_execution: () -> void
-      def execute_task: () -> void
-      def wait_for_dependencies: () -> void
-      def execute_clean_if_needed: () -> void
-      def start_async_clean: () -> void
-      def execute_clean: () -> void
-      def wait_for_clean_dependencies: () -> void
-      def mark_completed: () -> void
-      def mark_clean_completed: () -> void
-      def wait_for_completion: () -> untyped
+      def mark_running: () -> bool
+      def mark_completed: (untyped result) -> void
+      def mark_failed: (StandardError error) -> void
+      def mark_clean_completed: (untyped result) -> void
+      def wait_for_completion: () -> void
       def wait_for_clean_completion: () -> void
-      def debug_log: (String message) -> void
-      def log_start: () -> void
-      def log_completion: () -> void
-      def log_clean_start: () -> void
-      def log_clean_completion: () -> void
-      def register_with_progress_display: () -> void
-      def update_progress: (Symbol state, ?duration: Numeric?, ?error: Exception?) -> void
       def method_missing: (Symbol name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
       def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+
+      private
+
+      def trigger_execution_and_wait: () -> void
+      def trigger_clean_and_wait: () -> void
+      def execute_clean: () -> void
+      def wait_for_clean_dependencies: () -> void
+      def check_abort!: () -> void
+      def update_progress: (Symbol state, ?duration: Numeric?, ?error: Exception?) -> void
+      def debug_log: (String message) -> void
     end
 
-    # ParallelProgressDisplay class for progress visualization
-    class ParallelProgressDisplay
+    # TreeProgressDisplay class for tree-based progress visualization
+    class TreeProgressDisplay
       SPINNER_FRAMES: Array[String]
+      COLORS: Hash[Symbol, String]
+      ICONS: Hash[Symbol, String]
 
       @output: IO
       @tasks: Hash[Class, TaskProgress]
@@ -206,6 +230,30 @@ module Taski
       @spinner_index: Integer
       @renderer_thread: Thread?
       @running: bool
+      @nest_level: Integer
+      @root_task_class: Class?
+      @tree_structure: Hash[Symbol, untyped]?
+      @section_impl_map: Hash[Class, Class]
+      @last_line_count: Integer
+
+      # Shared class methods
+      def self.section_class?: (Class klass) -> bool
+      def self.nested_class?: (Class child_class, Class parent_class) -> bool
+      def self.render_static_tree: (Class root_task_class) -> String
+
+      # Static tree renderer (internal class)
+      class StaticTreeRenderer
+        @task_index_map: Hash[Class, Integer]
+
+        def render: (Class root_task_class) -> String
+
+        private
+
+        def build_tree: (Class task_class, String prefix, bool is_impl, Set[Class] ancestors) -> String
+        def render_dependency_branch: (Class dep, String prefix, bool is_last, bool is_impl, Set[Class] ancestors) -> String
+        def get_task_number: (Class task_class) -> String
+        def colored_type_label: (Class klass) -> String
+      end
 
       class TaskProgress
         attr_accessor state: Symbol
@@ -213,28 +261,39 @@ module Taski
         attr_accessor end_time: Time?
         attr_accessor error: Exception?
         attr_accessor duration: Numeric?
+        attr_accessor is_impl_candidate: bool
 
         def initialize: () -> void
       end
 
       def initialize: (?output: IO) -> void
+      def set_root_task: (Class root_task_class) -> void
+      def register_section_impl: (Class section_class, Class impl_class) -> void
       def register_task: (Class task_class) -> void
       def task_registered?: (Class task_class) -> bool
       def update_task: (Class task_class, state: Symbol, ?duration: Numeric?, ?error: Exception?) -> void
       def task_state: (Class task_class) -> Symbol?
-      def render: () -> void
       def start: () -> void
       def stop: () -> void
 
       private
 
-      def collect_task_lines: () -> Array[String]
+      def build_tree_structure: () -> void
+      def build_tree_node: (Class task_class, Set[Class] ancestors) -> Hash[Symbol, untyped]?
+      def register_tasks_from_tree: (Hash[Symbol, untyped] node) -> void
       def render_live: () -> void
       def render_final: () -> void
-      def format_task_line: (Class task_class, TaskProgress progress) -> String
-      def task_icon: (Symbol state) -> String
+      def build_tree_display: () -> Array[String]
+      def build_root_tree_lines: (Hash[Symbol, untyped] node, String prefix, Array[String] lines) -> void
+      def render_children: (Hash[Symbol, untyped] node, String prefix, Array[String] lines, Class parent_task_class, bool ancestor_selected) -> void
+      def format_tree_line: (Class task_class, TaskProgress? progress, bool is_impl, bool is_selected) -> String
+      def format_unknown_task: (Class task_class, ?bool is_selected) -> String
+      def task_status_icon: (Symbol state, bool is_selected) -> String
       def spinner_char: () -> String
+      def type_label_for: (Class task_class, ?bool is_selected) -> String
       def task_details: (TaskProgress progress) -> String
+      def section_class?: (Class klass) -> bool
+      def nested_class?: (Class child_class, Class parent_class) -> bool
     end
   end
 
@@ -246,19 +305,21 @@ module Taski
 
       private
 
-      def self.extract_run_method_location: (Class task_class) -> [String, Integer]?
+      def self.target_method_for: (Class task_class) -> Symbol
+      def self.extract_method_location: (Class task_class, Symbol method_name) -> [String, Integer]?
     end
 
     # Visitor class for AST traversal
     class Visitor < Prism::Visitor
       @target_task_class: Class
+      @target_method: Symbol
       @dependencies: Set[task_class]
-      @in_target_run_method: bool
+      @in_target_method: bool
       @current_namespace_path: Array[String?]
 
       attr_reader dependencies: Set[task_class]
 
-      def initialize: (Class task_class) -> void
+      def initialize: (Class task_class, Symbol target_method) -> void
       def visit_class_node: (Prism::ClassNode node) -> untyped
       def visit_module_node: (Prism::ModuleNode node) -> untyped
       def visit_def_node: (Prism::DefNode node) -> untyped
@@ -268,8 +329,10 @@ module Taski
 
       def within_namespace: (String? name) { () -> void } -> void
       def in_target_class?: () -> bool
+      def in_impl_method?: () -> bool
       def extract_constant_name: (untyped node) -> String?
       def detect_task_dependency: (Prism::CallNode node) -> void
+      def detect_impl_candidate: (untyped node) -> void
       def extract_receiver_constant: (untyped receiver) -> String?
       def resolve_and_add_dependency: (String constant_name) -> void
       def resolve_constant: (String name) -> task_class?