Method: TypeProf::Core::AST.create_node

Defined in:

lib/typeprof/core/ast.rb

.create_node(raw_node, lenv, use_result = true) ⇒ Object

: (untyped, TypeProf::Core::LocalEnv, ?bool) -> TypeProf::Core::AST::Node

# File 'lib/typeprof/core/ast.rb', line 22

def self.create_node(raw_node, lenv, use_result = true)
  while true
    case raw_node.type
    when :parentheses_node
      raw_node = raw_node.body
    when :implicit_node
      raw_node = raw_node.value
    else
      break
    end
  end

  case raw_node.type

  # definition
  when :statements_node then StatementsNode.new(raw_node, lenv, use_result)
  when :module_node then ModuleNode.new(raw_node, lenv, use_result)
  when :class_node then ClassNode.new(raw_node, lenv, use_result)
  when :singleton_class_node then SingletonClassNode.new(raw_node, lenv, use_result)
  when :def_node then DefNode.new(raw_node, lenv, use_result)
  when :alias_method_node then AliasNode.new(raw_node, lenv)
  when :undef_node then UndefNode.new(raw_node, lenv)

  # control
  when :and_node then AndNode.new(raw_node, lenv)
  when :or_node then OrNode.new(raw_node, lenv)
  when :if_node then IfNode.new(raw_node, lenv)
  when :unless_node then UnlessNode.new(raw_node, lenv)
  when :case_node then CaseNode.new(raw_node, lenv)
  when :case_match_node then CaseMatchNode.new(raw_node, lenv)
  when :while_node then WhileNode.new(raw_node, lenv)
  when :until_node then UntilNode.new(raw_node, lenv)
  when :break_node then BreakNode.new(raw_node, lenv)
  when :next_node then NextNode.new(raw_node, lenv)
  when :redo_node then RedoNode.new(raw_node, lenv)
  when :return_node then ReturnNode.new(raw_node, lenv)
  when :begin_node then BeginNode.new(raw_node, lenv)
  when :retry_node then RetryNode.new(raw_node, lenv)
  when :rescue_modifier_node then RescueModifierNode.new(raw_node, lenv)
  when :rescue_node then RescueNode.new(raw_node, lenv)

  # constants
  when :constant_read_node, :constant_path_node
    ConstantReadNode.new(raw_node, lenv)
  when :constant_write_node, :constant_path_write_node
    ConstantWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
  when :constant_operator_write_node
    read = ConstantReadNode.new(raw_node, lenv)
    rhs = OperatorNode.new(raw_node, read, lenv)
    ConstantWriteNode.new(raw_node, rhs, lenv)
  when :constant_or_write_node
    read = ConstantReadNode.new(raw_node, lenv)
    rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
    ConstantWriteNode.new(raw_node, rhs, lenv)
  when :constant_and_write_node
    read = ConstantReadNode.new(raw_node, lenv)
    rhs = AndNode.new(raw_node, read, raw_node.value, lenv)
    ConstantWriteNode.new(raw_node, rhs, lenv)
  when :constant_path_operator_write_node
    read = ConstantReadNode.new(raw_node.target, lenv)
    rhs = OperatorNode.new(raw_node, read, lenv)
    ConstantWriteNode.new(raw_node, rhs, lenv)
  when :constant_path_or_write_node
    read = ConstantReadNode.new(raw_node.target, lenv)
    rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
    ConstantWriteNode.new(raw_node, rhs, lenv)
  when :constant_path_and_write_node
    read = ConstantReadNode.new(raw_node.target, lenv)
    rhs = AndNode.new(raw_node, read, raw_node.value, lenv)
    ConstantWriteNode.new(raw_node, rhs, lenv)

  # variables
  when :local_variable_read_node
    LocalVariableReadNode.new(raw_node, lenv)
  when :it_local_variable_read_node
    ItLocalVariableReadNode.new(raw_node, lenv)
  when :local_variable_write_node
    LocalVariableWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
  when :local_variable_operator_write_node
    read = LocalVariableReadNode.new(raw_node, lenv)
    rhs = OperatorNode.new(raw_node, read, lenv)
    LocalVariableWriteNode.new(raw_node, rhs, lenv)
  when :local_variable_or_write_node
    read = LocalVariableReadNode.new(raw_node, lenv)
    rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
    LocalVariableWriteNode.new(raw_node, rhs, lenv)
  when :local_variable_and_write_node
    read = LocalVariableReadNode.new(raw_node, lenv)
    rhs = AndNode.new(raw_node, read, raw_node.value, lenv)
    LocalVariableWriteNode.new(raw_node, rhs, lenv)
  when :instance_variable_read_node
    InstanceVariableReadNode.new(raw_node, lenv)
  when :instance_variable_write_node
    InstanceVariableWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
  when :instance_variable_operator_write_node
    read = InstanceVariableReadNode.new(raw_node, lenv)
    rhs = OperatorNode.new(raw_node, read, lenv)
    InstanceVariableWriteNode.new(raw_node, rhs, lenv)
  when :instance_variable_or_write_node
    read = InstanceVariableReadNode.new(raw_node, lenv)
    rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
    InstanceVariableWriteNode.new(raw_node, rhs, lenv)
  when :instance_variable_and_write_node
    read = InstanceVariableReadNode.new(raw_node, lenv)
    rhs = AndNode.new(raw_node, read, raw_node.value, lenv)
    InstanceVariableWriteNode.new(raw_node, rhs, lenv)
  when :class_variable_read_node
    ClassVariableReadNode.new(raw_node, lenv)
  when :class_variable_write_node
    ClassVariableWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
  when :class_variable_operator_write_node
    read = ClassVariableReadNode.new(raw_node, lenv)
    rhs = OperatorNode.new(raw_node, read, lenv)
  when :class_variable_or_write_node
    read = ClassVariableReadNode.new(raw_node, lenv)
    rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
    ClassVariableWriteNode.new(raw_node, rhs, lenv)
  when :class_variable_and_write_node
    read = ClassVariableReadNode.new(raw_node, lenv)
    rhs = AndNode.new(raw_node, read, raw_node.value, lenv)
    ClassVariableWriteNode.new(raw_node, rhs, lenv)
  when :global_variable_read_node
    GlobalVariableReadNode.new(raw_node, lenv)
  when :global_variable_write_node
    GlobalVariableWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
  when :global_variable_operator_write_node
    read = GlobalVariableReadNode.new(raw_node, lenv)
    rhs = OperatorNode.new(raw_node, read, lenv)
    GlobalVariableWriteNode.new(raw_node, rhs, lenv)
  when :global_variable_or_write_node
    read = GlobalVariableReadNode.new(raw_node, lenv)
    rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
    GlobalVariableWriteNode.new(raw_node, rhs, lenv)
  when :global_variable_and_write_node
    read = GlobalVariableReadNode.new(raw_node, lenv)
    rhs = AndNode.new(raw_node, read, raw_node.value, lenv)
    GlobalVariableWriteNode.new(raw_node, rhs, lenv)
  when :numbered_reference_read_node
    RegexpReferenceReadNode.new(raw_node, lenv)
  when :back_reference_read_node
    RegexpReferenceReadNode.new(raw_node, lenv)

  # assignment targets
  when :index_operator_write_node
    read = IndexReadNode.new(raw_node, lenv)
    rhs = OperatorNode.new(raw_node, read, lenv)
    IndexWriteNode.new(raw_node, rhs, lenv)
  when :index_or_write_node
    read = IndexReadNode.new(raw_node, lenv)
    rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
    IndexWriteNode.new(raw_node, rhs, lenv)
  when :index_and_write_node
    read = IndexReadNode.new(raw_node, lenv)
    rhs = AndNode.new(raw_node, read, raw_node.value, lenv)
    IndexWriteNode.new(raw_node, rhs, lenv)
  when :call_operator_write_node
    read = CallReadNode.new(raw_node, lenv)
    rhs = OperatorNode.new(raw_node, read, lenv)
    CallWriteNode.new(raw_node, rhs, lenv)
  when :call_or_write_node
    read = CallReadNode.new(raw_node, lenv)
    rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
    CallWriteNode.new(raw_node, rhs, lenv)
  when :call_and_write_node
    read = CallReadNode.new(raw_node, lenv)
    rhs = AndNode.new(raw_node, read, raw_node.value, lenv)
    CallWriteNode.new(raw_node, rhs, lenv)
  when :multi_write_node then MultiWriteNode.new(raw_node, lenv)
  when :match_write_node then MatchWriteNode.new(raw_node, lenv)

  # value
  when :self_node then SelfNode.new(raw_node, lenv)
  when :nil_node then NilNode.new(raw_node, lenv)
  when :true_node then TrueNode.new(raw_node, lenv)
  when :false_node then FalseNode.new(raw_node, lenv)
  when :integer_node then IntegerNode.new(raw_node, lenv)
  when :float_node then FloatNode.new(raw_node, lenv)
  when :rational_node then RationalNode.new(raw_node, lenv)
  when :imaginary_node then ComplexNode.new(raw_node, lenv)
  when :source_file_node then StringNode.new(raw_node, lenv, "")
  when :source_line_node then IntegerNode.new(raw_node, lenv, 0)
  when :source_encoding_node then SourceEncodingNode.new(raw_node, lenv)
  when :symbol_node then SymbolNode.new(raw_node, lenv)
  when :interpolated_symbol_node then InterpolatedSymbolNode.new(raw_node, lenv)
  when :string_node then StringNode.new(raw_node, lenv, raw_node.content)
  when :interpolated_string_node then InterpolatedStringNode.new(raw_node, lenv)
  when :x_string_node then StringNode.new(raw_node, lenv, "")
  when :interpolated_x_string_node then InterpolatedStringNode.new(raw_node, lenv)
  when :regular_expression_node then RegexpNode.new(raw_node, lenv)
  when :interpolated_regular_expression_node then InterpolatedRegexpNode.new(raw_node, lenv)
  when :match_last_line_node then MatchLastLineNode.new(raw_node, lenv)
  when :interpolated_match_last_line_node then InterpolatedMatchLastLineNode.new(raw_node, lenv)
  when :range_node then RangeNode.new(raw_node, lenv)
  when :array_node then ArrayNode.new(raw_node, lenv)
  when :hash_node then HashNode.new(raw_node, lenv, false)
  when :keyword_hash_node then HashNode.new(raw_node, lenv, true)
  when :lambda_node then LambdaNode.new(raw_node, lenv)

  # misc
  when :defined_node then DefinedNode.new(raw_node, lenv)
  when :splat_node then SplatNode.new(raw_node, lenv)
  when :for_node then ForNode.new(raw_node, lenv)
  when :alias_global_variable_node then AliasGlobalVariableNode.new(raw_node, lenv)
  when :post_execution_node then PostExecutionNode.new(raw_node, lenv)
  when :flip_flop_node then FlipFlopNode.new(raw_node, lenv)
  when :shareable_constant_node then create_node(raw_node.write, lenv)
  when :match_required_node then MatchRequiredNode.new(raw_node, lenv)
  when :match_predicate_node then MatchPredicateNode.new(raw_node, lenv)

  # call
  when :super_node then SuperNode.new(raw_node, lenv)
  when :forwarding_super_node then ForwardingSuperNode.new(raw_node, lenv)
  when :yield_node then YieldNode.new(raw_node, lenv)
  when :call_node
    if !raw_node.receiver
      # TODO: handle them only when it is directly under class or module
      case raw_node.name
      when :include
        return IncludeMetaNode.new(raw_node, lenv)
      when :attr_reader
        return AttrReaderMetaNode.new(raw_node, lenv)
      when :attr_accessor
        return AttrAccessorMetaNode.new(raw_node, lenv)
      end
    end
    CallNode.new(raw_node, lenv)
  else
    pp raw_node
    raise "not supported yet: #{ raw_node.type }"
  end
end