houndstooth 0.1.0

data/lib/houndstooth/semantic_node/identifiers.rb

@@ -0,0 +1,308 @@
+module Houndstooth::SemanticNode
+    # A constant access, either with (`X::Y`) or without (`Y`) a leading target.
+    class Constant < Base
+        # @return [SemanticNode, nil]
+        attr_accessor :target
+
+        # @return [Symbol]
+        attr_accessor :name
+
+        register_ast_converter :const do |ast_node|
+            target, name = *ast_node
+            target = from_ast(target) if target
+            comments = shift_comments(ast_node)
+
+            Constant.new(
+                ast_node: ast_node,
+                comments: comments,
+
+                target: target,
+                name: name,
+            )
+        end
+
+        def to_instructions(block)
+            if target.nil?
+                target_value = nil
+            else
+                target.to_instructions(block)
+                target_value = block.instructions.last.result
+            end
+
+            type_arguments = get_type_arguments
+
+            block.instructions << I::ConstantAccessInstruction.new(
+                block: block,
+                node: self,
+                name: name,
+                target: target_value,
+                type_arguments: type_arguments,
+            )
+        end
+    end
+
+    # A special node which is only valid as the target of a `Constant`. Represents the `::A` syntax
+    # used to access a constant from the root namespace.
+    class ConstantBase < Base
+        register_ast_converter :cbase do |ast_node|
+            ConstantBase.new(ast_node: ast_node)
+        end 
+
+        def to_instructions(block)
+            block.instructions << I::ConstantBaseAccessInstruction.new(block: block, node: self)
+        end
+    end
+
+    # Assignment to a constant: `X::Y = 3`
+    class ConstantAssignment < Base
+        # @return [Constant, nil]
+        attr_accessor :target
+
+        # @return [Symbol]
+        attr_accessor :name
+
+        # @return [SemanticNode]
+        attr_accessor :value
+
+        register_ast_converter :casgn do |ast_node|
+            target, name, value = *ast_node
+            target = from_ast(target) if target
+            value = from_ast(value)
+            
+            ConstantAssignment.new(
+                ast_node: ast_node,
+                target: target,
+                name: name,
+                value: value,
+            )
+        end
+    end
+
+    # A utility mixin to model variable accesses and assignments, since the code is shared between
+    # local, instance, class, and global variables.
+    #
+    # This is not implemented as a class because an ambiguous `VariableAccess` would not be a valid
+    # node - the kind of variable must always be known at parse-time.
+    module VariableMixin
+        def variable_mixin(type)
+            # @return [Symbol]
+            attr_accessor :name
+            
+            register_ast_converter type do |ast_node|
+                self.new(ast_node: ast_node, name: ast_node.to_a.first)
+            end
+        end
+    end
+
+    # Represents a local variable. The parser looks at surrounding assignments and knows to generate
+    # these instead of `Send`s in the correct places.
+    class LocalVariable < Base
+        extend VariableMixin
+        variable_mixin :lvar
+
+        # @return [Boolean]
+        attr_accessor :fabricated
+        alias fabricated? fabricated
+
+        def self.fabricate
+            @@fabricate_counter ||= 0
+            @@fabricate_counter += 1
+
+            name = "___fabricated_#{@@fabricate_counter}"
+            LocalVariable.new(ast_node: nil, name: name, fabricated: true)
+        end
+
+        def to_instructions(block)
+            variable = block.resolve_local_variable(name.to_s, create: false)
+            block.instructions << I::AssignExistingInstruction.new(
+                block: block,
+                node: self,
+                variable: variable,
+                result: variable,
+            )
+        end
+    end
+
+    # Represents an instance variable.
+    class InstanceVariable < Base
+        extend VariableMixin
+        variable_mixin :ivar
+
+        def to_instructions(block)
+            block.instructions << I::InstanceVariableReadInstruction.new(
+                block: block,
+                node: self,
+                name: name.to_s,
+            )
+        end
+    end
+
+    # Represents a class variable.
+    class ClassVariable < Base
+        extend VariableMixin
+        variable_mixin :cvar
+    end
+
+    # Represents a global variable.
+    class GlobalVariable < Base
+        extend VariableMixin
+        variable_mixin :gvar
+    end
+
+    # Represents an assignment to a variable.
+    class VariableAssignment < Base
+        # @return [SemanticNode]
+        attr_accessor :target
+
+        # @return [SemanticNode]
+        attr_accessor :value
+
+        def self.from_ast_assignment(ast_node, variable_type, multiple_assignment_lhs: false, **_)
+            name, value = *ast_node
+
+            target = variable_type.new(
+                ast_node: ast_node,
+                name: name,
+            )
+
+            return target if multiple_assignment_lhs && value.nil?
+
+            value = from_ast(value)
+
+            VariableAssignment.new(
+                ast_node: ast_node,
+                target: target,
+                value: value,
+            )
+        end
+
+        register_ast_converter(:lvasgn) { |n, **o| from_ast_assignment(n, LocalVariable, **o)    }
+        register_ast_converter(:ivasgn) { |n, **o| from_ast_assignment(n, InstanceVariable, **o) }
+        register_ast_converter(:cvasgn) { |n, **o| from_ast_assignment(n, ClassVariable, **o)    }
+        register_ast_converter(:gvasgn) { |n, **o| from_ast_assignment(n, GlobalVariable, **o)   }
+
+        # Convert `x += 3` into `x = x + 3`
+        register_ast_converter :op_asgn do |ast_node, **o|
+            target, op, value = *ast_node
+
+            # Get target as an e.g. LocalVariable
+            target = from_ast(target, multiple_assignment_lhs: true)
+
+            # TODO: No nice way of converting between =/non-= versions of method names currently
+            # Also would need same considerations as noted for ||=/&&= to support
+            if target.is_a?(Send)
+                Houndstooth::Errors::Error.new(
+                    "Operator-assignment with a call on the left-hand side is not yet supported",
+                    [[ast_node.loc.dot.join(ast_node.loc.operator), "calls a method"]]
+                ).push
+                next nil
+            end
+
+            value = from_ast(value)
+
+            VariableAssignment.new(
+                ast_node: ast_node,
+                target: target,
+                value: Send.new(
+                    # Yeah, this is the same as the parent, but there's not really a better option
+                    ast_node: ast_node,
+
+                    method: op,
+                    target: target,
+
+                    arguments: [PositionalArgument.new(value)]
+                )
+            )
+        end
+
+        def to_instructions(block)
+            if !target.is_a?(LocalVariable) && !target.is_a?(InstanceVariable)
+                Houndstooth::Errors::Error.new(
+                    "Only local or instance variables are currently supported",
+                    [[target.ast_node.loc.name, "unsupported kind of variable"]]
+                ).push
+
+                block.instructions << I::LiteralInstruction.new(block: block, node: self, value: nil)
+                return
+            end
+
+            value.to_instructions(block)
+            if target.is_a?(LocalVariable)
+                block.instructions << I::AssignExistingInstruction.new(
+                    block: block,
+                    node: self,
+                    variable: block.instructions.last.result,
+                    result: block.resolve_local_variable(target.name.to_s, create: true),
+                )
+            else
+                block.instructions << I::InstanceVariableWriteInstruction.new(
+                    block: block,
+                    node: self,
+                    name: target.name.to_s,
+                    value: block.instructions.last.result,
+                )
+            end
+        end
+    end
+
+    # An assignment to multiple variables at once, destructuring the right-hand-side across the
+    # targets on the left-hand-side.
+    #
+    # A multiple assignment with one target is NOT the same as a single variable assignment!
+    #
+    #   a = [1, 2, 3]
+    #   p a # => [1, 2, 3]
+    #
+    #   a, = [1, 2, 3]
+    #   p a # => 1
+    #
+    class MultipleAssignment < Base
+        # @return [<SemanticNode>]
+        attr_accessor :targets
+
+        # Yep, value singular - "a, b = 1, 2" is desugared by the parser to have an array as the RHS
+        # @return [SemanticNode]
+        attr_accessor :value
+
+        register_ast_converter :masgn do |ast_node|
+            lhs, rhs = *ast_node
+
+            if lhs.type != :mlhs
+                Houndstooth::Errors::Error.new(
+                    "Unexpected left-hand side of multiple assignment",
+                    [[lhs.loc.expression, "expected list of variables to assign to"]]
+                ).push
+                next nil 
+            end
+
+            targets = lhs.to_a.map { |n| from_ast(n, multiple_assignment_lhs: true) }
+            value = from_ast(rhs)
+            
+            MultipleAssignment.new(
+                ast_node: ast_node,
+                targets: targets,
+                value: value,
+            )
+        end
+    end
+
+    # Represents a node which will be filled in magically by a parent node at code runtime, in cases
+    # where complex runtime behaviour means that desugaring isn't possible at parse-time.
+    #
+    # Currently, this is only used where the left-hand-side of a multiple assignment will call a
+    # method (with `Send`), e.g.:
+    #
+    #   self.a, self.b = *[1, 2]
+    #  
+    # This calls self.a=(1) and self.b=(2), but for other RHS values, we might not be able to 
+    # determine what the parameters will be at parse-time. So, this parses as a multiple assignment
+    # to targets (Send self.a=(MagicPlaceholder)) and (Send self.b=(MagicPlaceholder)).
+    #
+    # If you encounter this during node processing, something has probably gone wrong, and you 
+    # should have processed the enclosing multiple assignment earlier!
+    class MagicPlaceholder < Base
+        def initialize(**kwargs)
+            super(ast_node: nil, **kwargs)
+        end
+    end
+end 

data/lib/houndstooth/semantic_node/keywords.rb

@@ -0,0 +1,45 @@
+module Houndstooth::SemanticNode
+    # The `true` keyword.
+    class TrueKeyword < Base
+        register_ast_converter :true do |ast_node|
+            TrueKeyword.new(ast_node: ast_node)
+        end
+
+        def to_instructions(block)
+            block.instructions << I::LiteralInstruction.new(block: block, node: self, value: true)
+        end
+    end
+
+    # The `false` keyword.
+    class FalseKeyword < Base
+        register_ast_converter :false do |ast_node|
+            FalseKeyword.new(ast_node: ast_node)
+        end
+
+        def to_instructions(block)
+            block.instructions << I::LiteralInstruction.new(block: block, node: self, value: false)
+        end
+    end
+
+    # The `self` keyword.
+    class SelfKeyword < Base
+        register_ast_converter :self do |ast_node|
+            SelfKeyword.new(ast_node: ast_node)
+        end
+
+        def to_instructions(block)
+            block.instructions << I::SelfInstruction.new(block: block, node: self)
+        end
+    end
+
+    # The `nil` keyword.
+    class NilKeyword < Base
+        register_ast_converter :nil do |ast_node|
+            NilKeyword.new(ast_node: ast_node)
+        end
+
+        def to_instructions(block)
+            block.instructions << I::LiteralInstruction.new(block: block, node: self, value: nil)
+        end
+    end
+end

data/lib/houndstooth/semantic_node/literals.rb

@@ -0,0 +1,226 @@
+module Houndstooth::SemanticNode
+    # An integer literal.
+    class IntegerLiteral < Base
+        # @return [Integer]
+        attr_accessor :value
+
+        register_ast_converter :int do |ast_node|
+            IntegerLiteral.new(ast_node: ast_node, value: ast_node.to_a.first)
+        end
+
+        def to_instructions(block)
+            block.instructions << I::LiteralInstruction.new(block: block, node: self, value: value)
+        end
+    end
+
+    # A floating-point number literal.
+    class FloatLiteral < Base
+        # @return [Float]
+        attr_accessor :value
+
+        register_ast_converter :float do |ast_node|
+            FloatLiteral.new(ast_node: ast_node, value: ast_node.to_a.first)
+        end
+
+        def to_instructions(block)
+            block.instructions << I::LiteralInstruction.new(block: block, node: self, value: value)
+        end
+    end
+
+    # A string literal, possibly with interpolated components.
+    class StringLiteral < Base
+        # @return [<String, SemanticNode>]
+        attr_accessor :components
+
+        register_ast_converter :str do |ast_node|
+            StringLiteral.new(ast_node: ast_node, components: [ast_node.to_a.first])
+        end
+
+        register_ast_converter :dstr do |ast_node|
+            components = ast_node.to_a.map do |part|
+                if part.type == :str
+                    part.to_a.first
+                else
+                    from_ast(part)
+                end
+            end
+
+            StringLiteral.new(ast_node: ast_node, components: components)
+        end
+
+        def to_instructions(block)
+            # There are a few different ways to compile this, depending on what the string's made
+            # up of...
+            if components.all? { |c| c.is_a?(String) }
+                # All literals
+                value = components.join
+                block.instructions << I::LiteralInstruction.new(block: block, node: self, value: value)
+            else
+                # We need to actually generate instructions to concatenate the strings at runtime
+                # First evaluate each part of the string into a variable
+                string_part_variables = components.map do |c|
+                    if c.is_a?(String)
+                        block.instructions << I::LiteralInstruction.new(block: block, node: self, value: c)
+                    else
+                        c.to_instructions(block)
+                        block.instructions << I::ToStringInstruction.new(
+                            block: block,
+                            node: c,
+                            target: block.instructions.last.result,
+                        )
+                    end
+                    block.instructions.last.result
+                end
+
+                # Now generate code to concatenate these variables together
+                previous_variable = string_part_variables.first
+                string_part_variables[1..].each do |variable|
+                    block.instructions << I::SendInstruction.new(
+                        block: block, 
+                        node: self,
+                        target: previous_variable,
+                        method_name: :+,
+                        arguments: [I::PositionalArgument.new(variable)],
+                    )
+                    previous_variable = block.instructions.last.result
+                end
+            end
+        end
+    end
+
+    # A symbol literal, possibly with interpolated components.
+    class SymbolLiteral < Base
+        # @return [<String, SemanticNode>]
+        attr_accessor :components
+
+        register_ast_converter :sym do |ast_node|
+            SymbolLiteral.new(ast_node: ast_node, components: [ast_node.to_a.first.to_s])
+        end
+
+        register_ast_converter :dsym do |ast_node|
+            components = ast_node.to_a.map do |part|
+                if part.type == :str
+                    part.to_a.first.to_s
+                else
+                    from_ast(part)
+                end
+            end
+
+            SymbolLiteral.new(ast_node: ast_node, components: components)
+        end
+
+        def to_instructions(block)
+            # This logic is identical to translating a string literal - if it's all symbols we'll do
+            # it directly, otherwise we'll pretend we're a string and hand it off
+            if components.all? { |c| c.is_a?(String) }
+                # All literals
+                value = components.join
+                block.instructions << I::LiteralInstruction.new(block: block, node: self, value: value.to_sym)
+            else
+                # Pretend we're a string, and convert to a symbol with a call at the end
+                # Not 100% equivalent in terms of allocations, but Good Enough
+                StringLiteral.new(ast_node: ast_node, components: components).to_instructions(block)
+                block.instructions << I::SendInstruction.new(
+                    block: block,
+                    node: self,
+                    target: block.instructions.last.result,
+                    method_name: :to_sym,
+                )
+            end
+        end 
+    end
+
+    # An array literal.
+    class ArrayLiteral < Base
+        # @return [<SemanticNode>]
+        attr_accessor :nodes
+
+        register_ast_converter :array do |ast_node|
+            comments = shift_comments(ast_node)
+
+            ArrayLiteral.new(
+                ast_node: ast_node,
+                comments: comments,
+                nodes: ast_node.to_a.map { |node| from_ast(node) }
+            )
+        end
+
+        def to_instructions(block)
+            # Translate the array into `Array.new` followed by a sequence of calls to Array#push
+            type_arguments = get_type_arguments
+
+            block.instructions << I::ConstantBaseAccessInstruction.new(
+                block: block,
+                node: self,
+            )
+            block.instructions << I::ConstantAccessInstruction.new(
+                block: block,
+                node: self,
+                name: 'Array',
+                target: block.instructions.last.result,
+                type_arguments: type_arguments,
+            )
+            block.instructions << I::SendInstruction.new(
+                block: block,
+                node: self,
+                target: block.instructions.last.result,
+                method_name: :new,
+            )
+            array_var = block.instructions.last.result
+
+            nodes.each do |node|
+                node.to_instructions(block)
+                block.instructions << I::SendInstruction.new(
+                    block: block,
+                    node: node,
+                    target: array_var,
+                    method_name: :<<,
+                    arguments: [I::PositionalArgument.new(block.instructions.last.result)],
+                )
+            end
+
+            block.instructions << I::AssignExistingInstruction.new(
+                block: block,
+                node: self,
+                result: array_var,
+                variable: array_var,
+            )
+        end
+    end
+
+    # A hash literal.
+    class HashLiteral < Base
+        # @return [<(SemanticNode, SemanticNode)>]
+        attr_accessor :pairs
+
+        register_ast_converter :hash do |ast_node|
+            HashLiteral.new(
+                ast_node: ast_node,
+                pairs: ast_node.to_a.map { |pair| pair.to_a.map { from_ast(_1) } }
+            )
+        end
+    end
+
+    # A range literal.
+    class RangeLiteral < Base
+        # @return [SemanticNode, nil]
+        attr_accessor :first
+
+        # @return [SemanticNode, nil]
+        attr_accessor :last
+
+        # @return [bool]
+        attr_accessor :inclusive
+
+        register_ast_converter :irange, :erange do |ast_node|
+            first, last = ast_node.to_a.map { from_ast(_1) if _1 }
+
+            RangeLiteral.new(
+                ast_node: ast_node,
+                first: first,
+                last: last,
+                inclusive: (ast_node.type == :irange),
+            )
+        end
+    end
+end

data/lib/houndstooth/semantic_node/operators.rb

@@ -0,0 +1,126 @@
+module Houndstooth::SemanticNode
+    # A boolean AND operation: `a && b`,
+    #
+    # Unlike other infix operators, boolean AND and OR are not translated to a `Send`.
+    class BooleanAnd < Base
+        # @return [SemanticNode]
+        attr_accessor :left
+
+        # @return [SemanticNode]
+        attr_accessor :right
+
+        register_ast_converter :and do |ast_node|
+            left, right = ast_node.to_a.map { from_ast(_1) }
+
+            BooleanAnd.new(ast_node: ast_node, left: left, right: right)
+        end 
+    end
+
+    # A boolean OR operation: `a || b`,
+    #
+    # Unlike other infix operators, boolean AND and OR are not translated to a `Send`.
+    class BooleanOr < Base
+        # @return [SemanticNode]
+        attr_accessor :left
+
+        # @return [SemanticNode]
+        attr_accessor :right
+
+        register_ast_converter :or do |ast_node|
+            left, right = ast_node.to_a.map { from_ast(_1) }
+
+            BooleanOr.new(ast_node: ast_node, left: left, right: right)
+        end
+    end
+
+    # Note: It is *probably* possible to desugar the boolean-assign operators.
+    #
+    # I think `x ||= y` can be translated into:
+    #
+    #   if !(defined?(x) && x)
+    #     x = y
+    #   end
+    #   
+    # If the source of `x` is not idempotent, this is not _strictly_ correct - if our `x`
+    # was `do_something_random.x`, then we'd call `do_something_random` twice rather than
+    # once. But it might be close enough for static analysis purposes?
+
+    # An assignment using a boolean AND operator: `x &&= 3`
+    #
+    # This is NOT equivalent to `x = x && 3`.
+    class BooleanAndAssignment < Base
+        # @return [SemanticNode]
+        attr_accessor :target
+
+        # @return [SemanticNode]
+        attr_accessor :value
+
+        register_ast_converter :and_asgn do |ast_node|
+            target, value = *ast_node
+
+            # It's not *really* a multiple assignment LHS, but it's the easiest way to get e.g. a
+            # LocalVariable from (lvasgn :x), so we'll just pretend
+            target = from_ast(target, multiple_assignment_lhs: true)
+            value = from_ast(value)
+
+            BooleanAndAssignment.new(
+                ast_node: ast_node,
+                target: target,
+                value: value,
+            )
+        end
+    end
+
+    # An assignment using a boolean OR operator: `x ||= 3`
+    #
+    # This is NOT equivalent to `x = x || 3`.
+    class BooleanOrAssignment < Base
+        # @return [SemanticNode]
+        attr_accessor :target
+
+        # @return [SemanticNode]
+        attr_accessor :value
+
+        register_ast_converter :or_asgn do |ast_node|
+            target, value = *ast_node
+
+            # It's not *really* a multiple assignment LHS, but it's the easiest way to get e.g. a
+            # LocalVariable from (lvasgn :x), so we'll just pretend
+            target = from_ast(target, multiple_assignment_lhs: true)
+            value = from_ast(value)
+
+            BooleanOrAssignment.new(
+                ast_node: ast_node,
+                target: target,
+                value: value,
+            )
+        end
+    end
+
+    # A splat: `a = *b` or `[1, 2, *[3, 4], 5]`
+    class Splat < Base
+        # @return [SemanticNode]
+        attr_accessor :value
+
+        # It is possible for splats to appear on the LHS of an assigment, so we need to handle that
+        register_ast_converter :splat do |ast_node, multiple_assignment_lhs: false|
+            Splat.new(
+                ast_node: ast_node,
+                value: from_ast(
+                    ast_node.to_a.first,
+                    multiple_assignment_lhs: multiple_assignment_lhs,
+                )
+            )
+        end
+    end
+
+    # A `defined?` check: `defined? x`
+    class IsDefined < Base
+        # @return [SemanticNode]
+        attr_accessor :value
+
+        register_ast_converter :defined? do |ast_node|
+            IsDefined.new(ast_node: ast_node, value: from_ast(ast_node.to_a.first))
+        end
+    end
+end