typeprof 0.21.11 → 0.30.1

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

@@ -0,0 +1,123 @@
+module TypeProf::Core
+  class AST
+    class ModuleBaseNode < Node
+      def initialize(raw_node, lenv, raw_cpath, meta, raw_scope, use_result)
+        super(raw_node, lenv)
+
+        @cpath = AST.create_node(raw_cpath, lenv)
+        @static_cpath = AST.parse_cpath(raw_cpath, lenv.cref)
+        @tbl = raw_node.locals
+
+        # TODO: class Foo < Struct.new(:foo, :bar)
+
+        if @static_cpath
+          ncref = CRef.new(@static_cpath, meta ? :metaclass : :class, nil, lenv.cref)
+          nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+          @body = raw_scope ? AST.create_node(raw_scope, nlenv, use_result) : DummyNilNode.new(code_range, lenv)
+        else
+          @body = nil
+        end
+
+        @cname_code_range = meta ? nil : TypeProf::CodeRange.from_node(raw_node.constant_path)
+      end
+
+      attr_reader :tbl, :cpath, :static_cpath, :cname_code_range, :body
+
+      def subnodes = { cpath:, body: }
+      def attrs = { static_cpath:, tbl: }
+
+      def define0(genv)
+        @cpath.define(genv)
+        if @static_cpath
+          @body.define(genv)
+          @mod = genv.resolve_cpath(@static_cpath)
+          @mod_cdef = @mod.add_module_def(genv, self)
+        else
+          kind = self.is_a?(ModuleNode) ? "module" : "class"
+          @changes.add_diagnostic(:code_range, "TypeProf cannot analyze a non-static #{ kind }") # warning
+          nil
+        end
+      end
+
+      def define_copy(genv)
+        if @static_cpath
+          @mod_cdef.add_def(self)
+          @mod_cdef.remove_def(@prev_node)
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        if @static_cpath
+          @mod.remove_module_def(genv, self)
+          @body.undefine(genv)
+        end
+        @cpath.undefine(genv)
+      end
+
+      def install0(genv)
+        @cpath.install(genv)
+        if @static_cpath
+          @tbl.each {|var| @body.lenv.locals[var] = Source.new(genv.nil_type) }
+          @body.lenv.locals[:"*self"] = @body.lenv.cref.get_self(genv)
+
+          @mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@static_cpath)))
+          @changes.add_edge(genv, @mod_val, @mod_cdef.vtx)
+          ret = Vertex.new(self)
+          @changes.add_edge(genv, @body.install(genv), ret)
+          ret
+        else
+          Source.new
+        end
+      end
+
+      def modified_vars(tbl, vars)
+        # skip
+      end
+    end
+
+    class ModuleNode < ModuleBaseNode
+      def initialize(raw_node, lenv, use_result)
+        super(raw_node, lenv, raw_node.constant_path, false, raw_node.body, use_result)
+      end
+    end
+
+    class ClassNode < ModuleBaseNode
+      def initialize(raw_node, lenv, use_result)
+        super(raw_node, lenv, raw_node.constant_path, false, raw_node.body, use_result)
+        raw_superclass = raw_node.superclass
+        @superclass_cpath = raw_superclass ? AST.create_node(raw_superclass, lenv) : nil
+      end
+
+      attr_reader :superclass_cpath
+
+      def subnodes
+        super.merge!({ superclass_cpath: })
+      end
+
+      def define0(genv)
+        if @static_cpath && @superclass_cpath
+          const = @superclass_cpath.define(genv)
+          const.followers << genv.resolve_cpath(@static_cpath) if const
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        super(genv)
+        @superclass_cpath.undefine(genv) if @superclass_cpath
+      end
+
+      def install0(genv)
+        @superclass_cpath.install(genv) if @superclass_cpath
+        super(genv)
+      end
+    end
+
+    class SingletonClassNode < ModuleBaseNode
+      def initialize(raw_node, lenv, use_result)
+        super(raw_node, lenv, raw_node.expression, true, raw_node.body, use_result)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+module TypeProf::Core
+  class AST
+    class ArrayPatternNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @requireds = raw_node.requireds.map {|raw_pat| AST.create_pattern_node(raw_pat, lenv) }
+        @rest = !!raw_node.rest
+        @rest_pattern = raw_node.rest && raw_node.rest.expression ? AST.create_pattern_node(raw_node.rest.expression, lenv) : nil
+        @posts = raw_node.posts.map {|raw_pat| AST.create_pattern_node(raw_pat, lenv) }
+      end
+
+      attr_reader :requireds, :rest, :rest_pattern, :posts
+
+      def attrs = { rest: }
+      def subnodes = { requireds:, rest_pattern:, posts: }
+
+      def install0(genv)
+        @requireds.each do |pat|
+          pat.install(genv)
+        end
+        @rest_pattern.install(genv) if @rest_pattern
+        @posts.each do |pat|
+          pat.install(genv)
+        end
+      end
+    end
+
+    class HashPatternNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @keys = raw_node.elements.map {|raw_assoc| raw_assoc.key.value.to_sym }
+        @values = raw_node.elements.map {|raw_assoc| AST.create_pattern_node(raw_assoc.value, lenv) }
+        @rest = !!raw_node.rest
+        @rest_pattern = raw_node.rest && raw_node.rest.value ? AST.create_pattern_node(raw_node.rest.value, lenv) : nil
+      end
+
+      attr_reader :keys, :values, :rest, :rest_pattern
+
+      def attrs = { keys:, rest: }
+      def subnodes = { values:, rest_pattern: }
+
+      def install0(genv)
+        @values.each do |pat|
+          pat.install(genv)
+        end
+        @rest_pattern.install(genv) if @rest_pattern
+      end
+    end
+
+    class FindPatternNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @left = raw_node.left ? AST.create_pattern_node(raw_node.left.expression, lenv) : nil
+        @requireds = raw_node.requireds.map {|raw_elem| AST.create_pattern_node(raw_elem, lenv) }
+        @right = raw_node.right ? AST.create_pattern_node(raw_node.right.expression, lenv) : nil
+      end
+
+      attr_reader :left, :requireds, :right
+
+      def subnodes = { left:, requireds:, right: }
+
+      def install0(genv)
+        @left.install(genv) if @left
+        @requireds.each do |pat|
+          pat.install(genv)
+        end
+        @right.install(genv) if @right
+      end
+    end
+
+    class AltPatternNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @left = AST.create_pattern_node(raw_node.left, lenv)
+        @right = AST.create_pattern_node(raw_node.right, lenv)
+      end
+
+      attr_reader :left, :right
+
+      def subnodes = { left:, right: }
+
+      def install0(genv)
+        @left.install(genv)
+        @right.install(genv)
+      end
+    end
+
+    class CapturePatternNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @value = AST.create_pattern_node(raw_node.value, lenv)
+        @target = AST.create_pattern_node(raw_node.target, lenv)
+      end
+
+      attr_reader :value, :target
+
+      def subnodes = { value:, target: }
+
+      def install0(genv)
+        @value.install(genv)
+        @target.install(genv)
+      end
+    end
+
+    class IfPatternNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @cond = AST.create_node(raw_node.predicate, lenv)
+        raise if raw_node.statements.type != :statements_node
+        raise if raw_node.statements.body.size != 1
+        @body = AST.create_pattern_node(raw_node.statements.body[0], lenv)
+        raise if raw_node.subsequent
+      end
+
+      attr_reader :cond, :body
+
+      def subnodes = { cond:, body: }
+
+      def install0(genv)
+        @cond.install(genv)
+        @body.install(genv)
+      end
+    end
+
+    class PinnedPatternNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @expr = AST.create_node(raw_node.type == :pinned_variable_node ? raw_node.variable : raw_node.expression, lenv)
+      end
+
+      attr_reader :expr
+
+      def subnodes = { expr: }
+
+      def install0(genv)
+        @expr.install(genv)
+      end
+    end
+  end
+end