houndstooth 0.1.0

data/lib/houndstooth/semantic_node/control_flow.rb

@@ -0,0 +1,218 @@
+module Houndstooth::SemanticNode
+    # Used to group a sequence of nodes into one node - for example, when the body of a method
+    # definition contains more than one statement.
+    #
+    # In an ideal world, this class wouldn't exist, and instead we'd use an array everywhere it's
+    # possible for multiple nodes to exist. However, it turns out bodies are valid virtually
+    # everywhere! The following are valid snippets of Ruby code...
+    #
+    #   - 1 + (x = 2; x * x)
+    #   - something((a; b; c), (d; e; f))
+    #   - class (s = :IO; Object.const_get(s))::Something; end
+    class Body < Base
+        # @return [<SemanticNode>]
+        attr_accessor :nodes
+
+        register_ast_converter :begin do |ast_node|
+            if ast_node.to_a.length == 1
+                from_ast(ast_node.to_a.first)
+            else
+                Body.new(
+                    ast_node: ast_node,
+
+                    # Use a flat map so that we can flatten inner Body nodes into this one
+                    nodes: ast_node.to_a.flat_map do |ast_node|
+                        sem_node = from_ast(ast_node)
+                        if sem_node.is_a?(Body)
+                            sem_node.nodes
+                        else
+                            [sem_node]
+                        end
+                    end
+                )
+            end
+        end
+
+        def to_instructions(block)
+            # A body could signify a new scope, but not always, so we'll let the upper node in the
+            # tree create one if needed
+
+            if nodes.any?
+                nodes&.each do |node|
+                    node.to_instructions(block)
+                end
+            else
+                block << I::LiteralInstruction.new(block: block, node: self, value: nil)
+            end
+        end
+    end
+
+    # A conditional with true and false branches, used to represent `if` statements, ternary
+    # conditionals, and `case/when` constructs.
+    class Conditional < Base
+        # @return [SemanticNode]
+        attr_accessor :condition
+
+        # @return [SemanticNode]
+        attr_accessor :true_branch
+
+        # @return [SemanticNode, nil]
+        attr_accessor :false_branch
+
+        register_ast_converter :if do |ast_node|
+            condition, true_branch, false_branch = ast_node.to_a.map { from_ast(_1) if _1 }
+
+            Conditional.new(
+                ast_node: ast_node,
+                condition: condition,
+                true_branch: true_branch,
+                false_branch: false_branch,
+            )
+        end
+
+        register_ast_converter :case do |ast_node|
+            subject, *ast_whens, else_case = *ast_node
+
+            subject = from_ast(subject)
+            whens = ast_whens.map { |w| w.to_a.map { from_ast(_1) if _1 } } # [[value, body], ...]
+            else_case = from_ast(else_case) if else_case
+
+            # Convert into assignment and conditional chain
+            fabricated_subject_var = LocalVariable.fabricate
+            fabricated_subject_var_asgn = VariableAssignment.new(
+                ast_node: nil,
+                target: fabricated_subject_var,
+                value: subject,
+            )
+
+            # Add each `when` as the false branch of the previous one
+            root_conditional = nil
+            last_conditional = nil
+
+            whens.each.with_index do |_when, i|
+                value, body = *_when
+
+                this_conditional = Conditional.new(
+                    ast_node: ast_whens[i],
+
+                    # `when x` is equivalent to `x === subject`
+                    condition: Send.new(
+                        ast_node: ast_whens[i],
+
+                        target: value,
+                        method: :===,
+                        arguments: [PositionalArgument.new(fabricated_subject_var)],
+                    ),
+                    true_branch: body,
+                    false_branch: nil,
+                )
+
+                if last_conditional
+                    last_conditional.false_branch = this_conditional
+                    last_conditional = this_conditional
+                else
+                    root_conditional = this_conditional
+                    last_conditional = this_conditional
+                end
+            end
+
+            # It is syntactically enforced that a `case` will have at least one `when`, so this is safe
+            last_conditional.false_branch = else_case
+
+            Body.new(
+                ast_node: ast_node,
+                nodes: [
+                    fabricated_subject_var_asgn,
+                    root_conditional,
+                ]
+            )
+        end
+
+        def to_instructions(block)
+            condition.to_instructions(block)
+            ci = I::ConditionalInstruction.new(
+                block: block,
+                node: self,
+                condition: block.instructions.last.result,
+                true_branch: nil,
+                false_branch: nil,
+            )
+            ci.true_branch =
+                I::InstructionBlock.new(has_scope: false, parent: ci).tap do |blk|
+                    true_branch.to_instructions(blk)
+                end
+            ci.false_branch =
+                I::InstructionBlock.new(has_scope: false, parent: ci).tap do |blk|
+                    if false_branch.nil?
+                        blk.instructions << I::LiteralInstruction.new(block: blk, node: self, value: nil)
+                    else
+                        false_branch.to_instructions(blk)
+                    end
+                end
+            block.instructions << ci
+        end
+    end
+
+    # A while loop.
+    #
+    # TODO: It's possible this can be desugared into Kernel.loop { break unless condition; body }
+    class While < Base
+        # @return [SemanticNode]
+        attr_accessor :condition
+
+        # @return [SemanticNode]
+        attr_accessor :body
+
+        register_ast_converter :while do |ast_node|
+            condition, body = ast_node.to_a.map { from_ast(_1) if _1 }
+
+            While.new(
+                ast_node: ast_node,
+                condition: condition,
+                body: body,
+            )
+        end
+    end
+
+    # A mixin for defining expressions which affect the control of their enclosing contexts, e.g.
+    # `return` and `break`. These all take one optional arguments, so we can deduplicate their
+    # definitions.
+    module ControlExpressionMixin
+        def control_exp_mixin(type)
+            # @return [SemanticNode, nil]
+            attr_accessor :value
+            
+            register_ast_converter type do |ast_node|
+                if ast_node.to_a.length > 1
+                    value = ArrayLiteral.new(
+                        ast_node: ast_node,
+                        nodes: ast_node.to_a.map { from_ast(_1) },
+                    )
+                else
+                    value = ast_node.to_a.first
+                    value = from_ast(value) if value
+                end
+
+                self.new(ast_node: ast_node, value: value)
+            end
+        end
+    end
+
+    # A return expression.
+    class Return < Base
+        extend ControlExpressionMixin
+        control_exp_mixin :return
+    end
+
+    # A break expression.
+    class Break < Base
+        extend ControlExpressionMixin
+        control_exp_mixin :break
+    end
+
+    # A next expression.
+    class Next < Base
+        extend ControlExpressionMixin
+        control_exp_mixin :next
+    end
+end

data/lib/houndstooth/semantic_node/definitions.rb

@@ -0,0 +1,253 @@
+module Houndstooth::SemanticNode
+    # A method definition. Used for both standard method definitions (`def x()`) or definitions
+    # on a singleton (`def something.x()`).
+    class MethodDefinition < Base
+        # @return [Symbol]
+        attr_accessor :name
+
+        # @return [Parameters]
+        attr_accessor :parameters
+
+        # @return [SemanticNode, nil]
+        attr_accessor :target
+
+        # @return [SemanticNode]
+        attr_accessor :body
+
+        register_ast_converter :def do |ast_node|
+            name, parameters, body = *ast_node
+            comments = shift_comments(ast_node)
+
+            body = from_ast(body) if body
+            parameters = from_ast(parameters)
+
+            MethodDefinition.new(
+                ast_node: ast_node,
+                comments: comments,
+
+                name: name,
+                body: body,
+                parameters: parameters,
+                target: nil,
+            )
+        end
+
+        register_ast_converter :defs do |ast_node|
+            target, name, parameters, body = *ast_node
+            comments = shift_comments(ast_node)
+
+            target = from_ast(target)
+            body = from_ast(body) if body
+            parameters = from_ast(parameters)
+
+            MethodDefinition.new(
+                ast_node: ast_node,
+                comments: comments,
+
+                name: name,
+                body: body,
+                parameters: parameters,
+                target: target,
+            )
+        end
+
+        def to_instructions(block)
+            if target
+                target.to_instructions(block)
+                target_var = block.instructions.last.result
+            else
+                target_var = nil
+            end
+
+            mdi = I::MethodDefinitionInstruction.new(
+                node: self,
+                block: block,
+                name: name,
+                target: target_var,
+                body: nil,
+            )
+            mdi.body =
+                I::InstructionBlock.new(has_scope: true, parent: mdi).tap do |blk|
+                    if !parameters.add_to_instruction_block(blk)
+                        block.instructions << I::LiteralInstruction.new(node: self, block: block, value: nil)
+                        return
+                    end
+
+                    if body
+                        body.to_instructions(blk)
+                    else
+                        blk.instructions << I::LiteralInstruction.new(node: self, block: block, value: nil)
+                    end
+                end
+            block.instructions << mdi
+        end
+    end
+
+    module TypeDefinitionMixin
+        def type_definition_instructions(block, kind)
+            # Generate the name as instructions, but remove the last one to discover the name
+            # (Because the name will lead up to the target, e.g. class A::B)
+            # We measure how many instructions are generated to figure out if there was actually a
+            # leading path
+            instruction_count = block.instructions.length
+            name.to_instructions(block)
+            instruction_count = block.instructions.length - instruction_count
+            unless block.instructions.last.is_a?(I::ConstantAccessInstruction)
+                Houndstooth::Errors::Error.new(
+                    "Type name must be a constant",
+                    [[name.loc.expression, "unsupported"]]
+                ).push
+                return
+            end
+            type_name = block.instructions.pop.name.to_sym
+            if instruction_count > 1
+                type_target = block.instructions.last&.result
+            else
+                type_target = nil
+            end
+
+            if kind == :class
+                # Generate superclass, or if there isn't one, use Object
+                if superclass
+                    superclass.to_instructions(block)
+                    type_superclass = block.instructions.last.result
+                else
+                    block.instructions << I::ConstantBaseAccessInstruction.new(block: block, node: self)
+                    block.instructions << I::ConstantAccessInstruction.new(
+                        block: block,
+                        node: self,
+                        target: block.instructions.last.result,
+                        name: :Object,
+                    )
+                    type_superclass = block.instructions.last.result
+                end
+            end
+
+            # Build type
+            tdi = I::TypeDefinitionInstruction.new(
+                block: block,
+                node: self,
+                name: type_name,
+                kind: kind,
+                target: type_target,
+                superclass: type_superclass,
+                body: nil,
+            )
+            tdi.body =
+                I::InstructionBlock.new(has_scope: true, parent: tdi).tap do |blk|
+                    body&.to_instructions(blk)
+                end
+
+            block.instructions << tdi
+        end
+    end
+
+    # A class definition.
+    class ClassDefinition < Base
+        # @return [SemanticNode]
+        attr_accessor :name
+
+        # @return [SemanticNode, nil]
+        attr_accessor :superclass
+
+        # @return [SemanticNode, nil]
+        attr_accessor :body
+
+        register_ast_converter :class do |ast_node|
+            name, superclass, body = *ast_node
+            comments = shift_comments(ast_node)
+
+            name = from_ast(name)
+            superclass = from_ast(superclass) if superclass
+            body = from_ast(body) if body
+
+            ClassDefinition.new(
+                ast_node: ast_node,
+                comments: comments,
+
+                name: name,
+                superclass: superclass,
+                body: body,
+            )
+        end
+
+        include TypeDefinitionMixin
+        def to_instructions(block)
+            type_definition_instructions(block, :class)
+        end
+    end
+
+    # A singleton class accessor: `class << x`.
+    class SingletonClass < Base
+        # @return [SemanticNode]
+        attr_accessor :target
+
+        # @return [SemanticNode, nil]
+        attr_accessor :body
+
+        register_ast_converter :sclass do |ast_node|
+            target, body = *ast_node
+
+            target = from_ast(target)
+            body = from_ast(body) if body
+
+            SingletonClass.new(
+                ast_node: ast_node,                
+                target: target,
+                body: body,
+            )
+        end
+    end
+
+    # A module definition.
+    class ModuleDefinition < Base
+        # @return [SemanticNode]
+        attr_accessor :name
+
+        # @return [SemanticNode, nil]
+        attr_accessor :body
+
+        register_ast_converter :module do |ast_node|
+            name, body = *ast_node
+            comments = shift_comments(ast_node)
+
+            name = from_ast(name)
+            body = from_ast(body) if body
+
+            ModuleDefinition.new(
+                ast_node: ast_node,
+                comments: comments,
+                
+                name: name,
+                body: body,
+            )
+        end
+
+        include TypeDefinitionMixin
+        def to_instructions(block)
+            type_definition_instructions(block, :module)
+        end
+    end
+
+    # An alias.
+    #
+    # Aliases are usually between statically-named methods given with just identifiers, but they
+    # can also be between methods named with dynamic symbols, and even between global variables.
+    class Alias < Base
+        # @return [SemanticNode]
+        attr_accessor :from
+
+        # @return [SemanticNode]
+        attr_accessor :to
+
+        register_ast_converter :alias do |ast_node|
+            to, from = ast_node.to_a.map { from_ast(_1) }
+
+            Alias.new(
+                ast_node: ast_node,
+                from: from,
+                to: to,
+            )
+        end
+    end
+end