typeprof 0.31.0 → 0.32.0

data/lib/typeprof/core/ast/sig_type.rb

@@ -2,7 +2,10 @@ module TypeProf::Core
   class AST
     def self.typecheck_for_module(genv, changes, f_mod, f_args, a_vtx, subst)
       changes.add_edge(genv, a_vtx, changes.target)
+      found_any = false
       a_vtx.each_type do |ty|
+        next if ty.is_a?(Type::Bot)
+        found_any = true
         ty = ty.base_type(genv)
         while ty
           if ty.mod == f_mod && ty.is_a?(Type::Instance)
@@ -25,7 +28,7 @@ module TypeProf::Core
           ty = genv.get_superclass_type(ty, changes, {})
         end
       end
-      return false
+      return !found_any
     end
 
     def self.typecheck_for_prepended_modules(genv, changes, a_ty, f_mod, f_args, subst)
@@ -33,7 +36,7 @@ module TypeProf::Core
         if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
           prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, {}, a_ty)
         else
-          type_params = prep_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          type_params = prep_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
           prep_ty = Type::Instance.new(genv, prep_mod, type_params)
         end
         if prep_ty.mod == f_mod
@@ -58,7 +61,7 @@ module TypeProf::Core
         if inc_decl.is_a?(AST::SigIncludeNode) && inc_mod.type_params
           inc_ty = genv.get_instance_type(inc_mod, inc_decl.args, changes, {}, a_ty)
         else
-          type_params = inc_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          type_params = inc_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
           inc_ty = Type::Instance.new(genv, inc_mod, type_params)
         end
         if inc_ty.mod == f_mod
@@ -108,13 +111,19 @@ module TypeProf::Core
           param = raw_decl.type.rest_positionals
           @rest_positionals = param ? AST.create_rbs_type(param.type, lenv) : nil
 
-          @req_keywords = raw_decl.type.required_keywords.to_h do |key, ty|
+          @req_keyword_keys = []
+          @req_keyword_values = []
+          raw_decl.type.required_keywords.each do |key, ty|
             raise "unsupported argument type: #{ ty.class }" if !ty.is_a?(RBS::Types::Function::Param)
-            [key, AST.create_rbs_type(ty.type, lenv)]
+            @req_keyword_keys << key
+            @req_keyword_values << AST.create_rbs_type(ty.type, lenv)
           end
-          @opt_keywords = raw_decl.type.optional_keywords.to_h do |key, ty|
+          @opt_keyword_keys = []
+          @opt_keyword_values = []
+          raw_decl.type.optional_keywords.each do |key, ty|
             raise "unsupported argument type: #{ ty.class }" if !ty.is_a?(RBS::Types::Function::Param)
-            [key, AST.create_rbs_type(ty.type, lenv)]
+            @opt_keyword_keys << key
+            @opt_keyword_values << AST.create_rbs_type(ty.type, lenv)
           end
           param = raw_decl.type.rest_keywords
           @rest_keywords = param ? AST.create_rbs_type(param.type, lenv) : nil
@@ -124,8 +133,10 @@ module TypeProf::Core
           @post_positionals = []
           @opt_positionals = []
           @rest_positionals = SigTyBaseAnyNode.new(raw_decl, lenv)
-          @req_keywords = {}
-          @opt_keywords = {}
+          @req_keyword_keys = []
+          @req_keyword_values = []
+          @opt_keyword_keys = []
+          @opt_keyword_values = []
           @rest_keywords = nil
         end
 
@@ -137,8 +148,10 @@ module TypeProf::Core
       attr_reader :post_positionals
       attr_reader :opt_positionals
       attr_reader :rest_positionals
-      attr_reader :req_keywords
-      attr_reader :opt_keywords
+      attr_reader :req_keyword_keys
+      attr_reader :req_keyword_values
+      attr_reader :opt_keyword_keys
+      attr_reader :opt_keyword_values
       attr_reader :rest_keywords
       attr_reader :return_type
 
@@ -148,12 +161,17 @@ module TypeProf::Core
         post_positionals:,
         opt_positionals:,
         rest_positionals:,
-        req_keywords:,
-        opt_keywords:,
+        req_keyword_values:,
+        opt_keyword_values:,
         rest_keywords:,
         return_type:,
       }
-      def attrs = { type_params:, block_required: }
+      def attrs = {
+        type_params:,
+        req_keyword_keys:,
+        opt_keyword_keys:,
+        block_required:,
+      }
     end
 
     class SigTyNode < Node
@@ -182,6 +200,7 @@ module TypeProf::Core
       def typecheck(genv, changes, vtx, subst)
         changes.add_edge(genv, vtx, changes.target)
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
           return false unless ty == genv.true_type || ty == genv.false_type
         end
         true
@@ -204,6 +223,7 @@ module TypeProf::Core
       def typecheck(genv, changes, vtx, subst)
         changes.add_edge(genv, vtx, changes.target)
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
           return false unless ty == genv.nil_type
         end
         true
@@ -287,11 +307,11 @@ module TypeProf::Core
 
     class SigTyBaseBottomNode < SigTyNode
       def covariant_vertex0(genv, changes, vtx, subst)
-        changes.add_edge(genv, Source.new(Type::Bot.new(genv)), vtx)
+        changes.add_edge(genv, Source.new(genv.bot_type), vtx)
       end
 
       def contravariant_vertex0(genv, changes, vtx, subst)
-        changes.add_edge(genv, Source.new(Type::Bot.new(genv)), vtx)
+        changes.add_edge(genv, Source.new(genv.bot_type), vtx)
       end
 
       def typecheck(genv, changes, vtx, subst)
@@ -530,6 +550,8 @@ module TypeProf::Core
         name = raw_decl.name
         @cpath = name.namespace.path + [name.name]
         @toplevel = name.namespace.absolute?
+        # RBS::Types::ClassSingleton#args was added in RBS 4.0
+        @args = raw_decl.respond_to?(:args) ? raw_decl.args.map {|arg| AST.create_rbs_type(arg, lenv) } : []
       end
 
       attr_reader :cpath, :toplevel
@@ -578,7 +600,10 @@ module TypeProf::Core
         return unless cpath
         f_mod = genv.resolve_cpath(cpath)
         changes.add_edge(genv, vtx, changes.target)
+        found_any = false
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
+          found_any = true
           case ty
           when Type::Singleton
             if f_mod.module?
@@ -593,7 +618,7 @@ module TypeProf::Core
             end
           end
         end
-        false
+        !found_any
       end
 
       def show
@@ -714,7 +739,10 @@ module TypeProf::Core
 
       def typecheck(genv, changes, vtx, subst)
         changes.add_edge(genv, vtx, changes.target)
+        found_any = false
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
+          found_any = true
           case ty
           when Type::Array
             next if ty.elems.size != @types.size
@@ -729,7 +757,7 @@ module TypeProf::Core
             return true
           end
         end
-        false
+        !found_any
       end
 
       def show
@@ -740,16 +768,18 @@ module TypeProf::Core
     class SigTyRecordNode < SigTyNode
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
-        @fields = raw_decl.fields.transform_values { |val| AST.create_rbs_type(val, lenv) }
+        @keys = raw_decl.fields.keys
+        @vals = raw_decl.fields.values.map { |val| AST.create_rbs_type(val, lenv) }
       end
 
-      attr_reader :fields
-      def subnodes = { fields: }
+      attr_reader :keys, :vals
+      def subnodes = { vals: }
+      def attrs = { keys: }
 
       def covariant_vertex0(genv, changes, vtx, subst)
         field_vertices = {}
-        @fields.each do |key, field_node|
-          field_vertices[key] = field_node.covariant_vertex(genv, changes, subst)
+        @keys.zip(@vals) do |key, val_node|
+          field_vertices[key] = val_node.covariant_vertex(genv, changes, subst)
         end
 
         # Create base Hash type for Record
@@ -766,8 +796,8 @@ module TypeProf::Core
 
       def contravariant_vertex0(genv, changes, vtx, subst)
         field_vertices = {}
-        @fields.each do |key, field_node|
-          field_vertices[key] = field_node.contravariant_vertex(genv, changes, subst)
+        @keys.zip(@vals) do |key, val_node|
+          field_vertices[key] = val_node.contravariant_vertex(genv, changes, subst)
         end
 
         # Create base Hash type for Record
@@ -784,22 +814,25 @@ module TypeProf::Core
 
       def typecheck(genv, changes, vtx, subst)
         changes.add_edge(genv, vtx, changes.target)
+        found_any = false
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
+          found_any = true
           case ty
           when Type::Hash
-            @fields.each do |key, field_node|
+            @keys.zip(@vals) do |key, val_node|
               val_vtx = ty.get_value(key)
-              return false unless field_node.typecheck(genv, changes, val_vtx, subst)
+              return false unless val_node.typecheck(genv, changes, val_vtx, subst)
             end
             return true
           end
         end
-        false
+        !found_any
       end
 
       def show
-        field_strs = @fields.map do |key, field_node|
-          "#{ key }: #{ field_node.show }"
+        field_strs = @keys.zip(@vals).map do |key, val_node|
+          "#{ key }: #{ val_node.show }"
         end
         "{ #{ field_strs.join(", ") } }"
       end
@@ -826,7 +859,7 @@ module TypeProf::Core
       end
 
       def typecheck(genv, changes, vtx, subst)
-        changes.add_edge(genv, vtx, subst[@var]) unless vtx == subst[@var]
+        changes.add_edge(genv, vtx.new_vertex(genv, self), subst[@var]) unless vtx == subst[@var]
         true
       end
 
@@ -855,6 +888,16 @@ module TypeProf::Core
       end
 
       def typecheck(genv, changes, vtx, subst)
+        # For optional type T?, check if all non-nil types match T.
+        # nil is always acceptable.
+        changes.add_edge(genv, vtx, changes.target)
+        has_non_nil = false
+        vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
+          next if ty == genv.nil_type
+          has_non_nil = true
+        end
+        return true unless has_non_nil
         @type.typecheck(genv, changes, vtx, subst)
       end
 
@@ -900,13 +943,16 @@ module TypeProf::Core
       def typecheck(genv, changes, vtx, subst)
         if @lit.is_a?(::Symbol)
           changes.add_edge(genv, vtx, changes.target)
+          found_any = false
           vtx.each_type do |ty|
+            next if ty.is_a?(Type::Bot)
+            found_any = true
             case ty
             when Type::Symbol
               return true if ty.sym == @lit
             end
           end
-          return false
+          return !found_any
         end
         f_mod = get_type(genv).mod
         AST.typecheck_for_module(genv, changes, f_mod, [], vtx, subst)

data/lib/typeprof/core/ast/value.rb

@@ -5,7 +5,7 @@ module TypeProf::Core
       when :string_node
         AST.create_node(raw_part, lenv)
       when :embedded_statements_node
-        raw_part.statements ? AST.create_node(raw_part.statements, lenv) : DummyNilNode.new(TypeProf::CodeRange.from_node(raw_part), lenv)
+        raw_part.statements ? AST.create_node(raw_part.statements, lenv) : DummyNilNode.new(lenv.code_range_from_node(raw_part), lenv)
       when :embedded_variable_node
         AST.create_node(raw_part.variable, lenv)
       else
@@ -275,7 +275,7 @@ module TypeProf::Core
             if raw_elem.value
               @vals << AST.create_node(raw_elem.value, lenv)
             else
-              @vals << DummyNilNode.new(code_range, lenv)
+              @vals << nil
             end
             @splat = true
           else
@@ -293,15 +293,20 @@ module TypeProf::Core
         unified_key = Vertex.new(self)
         unified_val = Vertex.new(self)
         literal_pairs = {}
+        all_symbol_keys = true
         @keys.zip(@vals) do |key, val|
           if key
             k = key.install(genv).new_vertex(genv, self)
             v = val.install(genv).new_vertex(genv, self)
             @changes.add_edge(genv, k, unified_key)
             @changes.add_edge(genv, v, unified_val)
-            literal_pairs[key.lit] = v if key.is_a?(SymbolNode)
+            if key.is_a?(SymbolNode)
+              literal_pairs[key.lit] = v
+            else
+              all_symbol_keys = false
+            end
           else
-            if val.is_a?(DummyNilNode)
+            if val.nil?
               h = @lenv.get_var(:"**anonymous_keyword")
             else
               h = val.install(genv)
@@ -310,10 +315,13 @@ module TypeProf::Core
             @changes.add_hash_splat_box(genv, h, unified_key, unified_val)
           end
         end
+        base_hash_type = genv.gen_hash_type(unified_key, unified_val)
         if @splat
-          Source.new(genv.gen_hash_type(unified_key, unified_val))
+          Source.new(base_hash_type)
+        elsif all_symbol_keys
+          Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
         else
-          Source.new(Type::Hash.new(genv, literal_pairs, genv.gen_hash_type(unified_key, unified_val)))
+          Source.new(Type::Hash.new(genv, literal_pairs, base_hash_type))
         end
       end
     end

data/lib/typeprof/core/ast/variable.rb

@@ -46,7 +46,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -68,6 +68,13 @@ module TypeProf::Core
         super(pos, &blk)
       end
 
+      def narrowings
+        @narrowings ||= [
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(false) }),
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(true) }),
+        ]
+      end
+
       def modified_vars(tbl, vars)
         vars << self.var if tbl.include?(self.var)
       end
@@ -109,7 +116,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -191,7 +198,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -264,7 +271,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 

data/lib/typeprof/core/ast.rb

@@ -1,6 +1,6 @@
 module TypeProf::Core
   class AST
-    def self.parse_rb(path, src)
+    def self.parse_rb(path, src, position_encoding)
       result = Prism.parse(src)
 
       return nil unless result.errors.empty?
@@ -10,19 +10,58 @@ module TypeProf::Core
 
       raise unless raw_scope.type == :program_node
 
-      Fiber[:comments] = result.comments
+      prism_source = result.source
+      file_context = FileContext.new(path, position_encoding, prism_source, result.comments)
 
       cref = CRef::Toplevel
-      lenv = LocalEnv.new(path, cref, {}, [])
+      lenv = LocalEnv.new(file_context, cref, {}, [])
 
-      ProgramNode.new(raw_scope, lenv)
+      ignore_ranges = collect_ignore_ranges(result)
+      ProgramNode.new(raw_scope, lenv, ignore_ranges: ignore_ranges)
     end
 
-    #: (untyped, TypeProf::Core::LocalEnv, ?bool) -> TypeProf::Core::AST::Node
-    def self.create_node(raw_node, lenv, use_result = true)
+    # Collect line ranges marked with `# typeprof:ignore` comments.
+    # Each range is suppressed in ProgramNode#each_diagnostic.
+    #
+    # Inline form (suppresses the line containing the comment):
+    #     foo(1, 2) # typeprof:ignore
+    #
+    # Block form (suppresses lines between :start and :end):
+    #     # typeprof:ignore:start
+    #     foo(1, 2)
+    #     # typeprof:ignore:end
+    #
+    # An unmatched `:start` extends to the end of the file.
+    IGNORE_RE       = /\A#\s*typeprof:ignore\s*\z/
+    IGNORE_START_RE = /\A#\s*typeprof:ignore:start\s*\z/
+    IGNORE_END_RE   = /\A#\s*typeprof:ignore:end\s*\z/
+    def self.collect_ignore_ranges(prism_result)
+      ranges = []
+      start_line = nil
+      prism_result.comments.each do |c|
+        text = c.location.slice
+        line = c.location.start_line
+        if text.match?(IGNORE_START_RE)
+          start_line ||= line
+        elsif text.match?(IGNORE_END_RE)
+          if start_line
+            ranges << (start_line..line)
+            start_line = nil
+          end
+        elsif text.match?(IGNORE_RE)
+          ranges << (line..line)
+        end
+      end
+      ranges << (start_line..Float::INFINITY) if start_line
+      ranges
+    end
+
+    #: (untyped, TypeProf::Core::LocalEnv, ?bool, ?bool) -> TypeProf::Core::AST::Node
+    def self.create_node(raw_node, lenv, use_result = true, allow_meta = false)
       while true
         case raw_node.type
         when :parentheses_node
+          return DummyNilNode.new(lenv.code_range_from_node(raw_node), lenv) if raw_node.body.nil?
           raw_node = raw_node.body
         when :implicit_node
           raw_node = raw_node.value
@@ -64,7 +103,13 @@ module TypeProf::Core
       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)
+        if (members = detect_struct_new(raw_node.value))
+          StructNewNode.new(raw_node, members, :struct, lenv)
+        elsif (members = detect_data_define(raw_node.value))
+          StructNewNode.new(raw_node, members, :data, lenv)
+        else
+          ConstantWriteNode.new(raw_node, AST.create_node(raw_node.value, lenv), lenv)
+        end
       when :constant_operator_write_node
         read = ConstantReadNode.new(raw_node, lenv)
         rhs = OperatorNode.new(raw_node, read, lenv)
@@ -132,6 +177,7 @@ module TypeProf::Core
       when :class_variable_operator_write_node
         read = ClassVariableReadNode.new(raw_node, lenv)
         rhs = OperatorNode.new(raw_node, read, lenv)
+        ClassVariableWriteNode.new(raw_node, rhs, lenv)
       when :class_variable_or_write_node
         read = ClassVariableReadNode.new(raw_node, lenv)
         rhs = OrNode.new(raw_node, read, raw_node.value, lenv)
@@ -233,15 +279,20 @@ module TypeProf::Core
       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
+        if allow_meta && !raw_node.receiver && !lenv.cref.mid && [:class, :metaclass].include?(lenv.cref.scope_level)
           case raw_node.name
           when :include
             return IncludeMetaNode.new(raw_node, lenv)
           when :attr_reader
             return AttrReaderMetaNode.new(raw_node, lenv)
+          when :attr_writer
+            return AttrWriterMetaNode.new(raw_node, lenv)
           when :attr_accessor
             return AttrAccessorMetaNode.new(raw_node, lenv)
+          when :module_function
+            if raw_node.arguments.nil?
+              return ModuleFunctionMetaNode.new(raw_node, lenv)
+            end
           end
         end
         CallNode.new(raw_node, lenv)
@@ -252,7 +303,7 @@ module TypeProf::Core
     end
 
     def self.create_target_node(raw_node, lenv)
-      dummy_node = DummyRHSNode.new(TypeProf::CodeRange.from_node(raw_node.location), lenv)
+      dummy_node = DummyRHSNode.new(lenv.code_range_from_node(raw_node.location), lenv)
       case raw_node.type
       when :local_variable_target_node
         LocalVariableWriteNode.new(raw_node, dummy_node, lenv)
@@ -270,6 +321,8 @@ module TypeProf::Core
         IndexWriteNode.new(raw_node, dummy_node, lenv)
       when :call_target_node
         CallWriteNode.new(raw_node, dummy_node, lenv)
+      when :multi_target_node
+        MultiTargetNode.new(raw_node, dummy_node, lenv)
       else
         pp raw_node
         raise "not supported yet: #{ raw_node.type }"
@@ -303,7 +356,7 @@ module TypeProf::Core
       when :pinned_expression_node then PinnedPatternNode.new(raw_node, lenv)
 
       when :local_variable_target_node
-        dummy_node = DummyRHSNode.new(TypeProf::CodeRange.from_node(raw_node.location), lenv)
+        dummy_node = DummyRHSNode.new(lenv.code_range_from_node(raw_node.location), lenv)
         LocalVariableWriteNode.new(raw_node, dummy_node, lenv)
 
       when :constant_read_node, :constant_path_node
@@ -362,11 +415,12 @@ module TypeProf::Core
       return cpath + names.reverse if cpath
     end
 
-    def self.parse_rbs(path, src)
+    def self.parse_rbs(path, src, position_encoding)
       _buffer, _directives, raw_decls = RBS::Parser.parse_signature(src)
 
       cref = CRef::Toplevel
-      lenv = LocalEnv.new(path, cref, {}, [])
+      file_context = FileContext.new(path, position_encoding)
+      lenv = LocalEnv.new(file_context, cref, {}, [])
 
       raw_decls.map do |raw_decl|
         AST.create_rbs_decl(raw_decl, lenv)
@@ -383,7 +437,10 @@ module TypeProf::Core
         SigInterfaceNode.new(raw_decl, lenv)
       when RBS::AST::Declarations::Constant
         SigConstNode.new(raw_decl, lenv)
-      when RBS::AST::Declarations::AliasDecl
+      when RBS::AST::Declarations::ClassAlias
+        SigClassAliasNode.new(raw_decl, lenv)
+      when RBS::AST::Declarations::ModuleAlias
+        SigModuleAliasNode.new(raw_decl, lenv)
       when RBS::AST::Declarations::TypeAlias
         SigTypeAliasNode.new(raw_decl, lenv)
         # TODO: check
@@ -479,5 +536,31 @@ module TypeProf::Core
         raise "unknown RBS type: #{ raw_decl.class }"
       end
     end
+
+    def self.detect_struct_new(raw_value)
+      return nil unless raw_value.type == :call_node
+      return nil unless raw_value.name == :new
+      recv = raw_value.receiver
+      return nil unless recv&.type == :constant_read_node && recv.name == :Struct
+      extract_symbol_args(raw_value)
+    end
+
+    def self.detect_data_define(raw_value)
+      return nil unless raw_value.type == :call_node
+      return nil unless raw_value.name == :define
+      recv = raw_value.receiver
+      return nil unless recv&.type == :constant_read_node && recv.name == :Data
+      extract_symbol_args(raw_value)
+    end
+
+    def self.extract_symbol_args(raw_call)
+      return nil unless raw_call.arguments
+      members = []
+      raw_call.arguments.arguments.each do |arg|
+        return nil unless arg.type == :symbol_node
+        members << arg.value.to_sym
+      end
+      members
+    end
   end
 end