steep 0.11.1 → 0.12.0

data/lib/steep/interface/substitution.rb

@@ -17,6 +17,20 @@ module Steep
         new(dictionary: {}, instance_type: AST::Types::Instance.new, module_type: AST::Types::Class.new, self_type: AST::Types::Self.new)
       end
 
+      def to_s
+        a = []
+
+        dictionary.each do |x, ty|
+          a << "#{x} -> #{ty}"
+        end
+
+        a << "[instance_type] -> #{instance_type}"
+        a << "[module_type] -> #{module_type}"
+        a << "[self_type] -> #{self_type}"
+
+        "{ #{a.join(", ")} }"
+      end
+
       def [](key)
         dictionary[key] or raise "Unknown variable: #{key}"
       end
@@ -55,6 +69,14 @@ module Steep
             raise "Duplicated key on merge!: #{key}, #{a}, #{b}"
           end
         end
+        self
+      end
+
+      def merge(s)
+        Substitution.new(dictionary: dictionary.dup,
+                         instance_type: instance_type,
+                         module_type: module_type,
+                         self_type: self_type).merge!(s)
       end
 
       def add!(v, ty)

data/lib/steep/project.rb

@@ -1,251 +1,43 @@
 module Steep
   class Project
-    class SignatureLoaded
-      attr_reader :check
-      attr_reader :loaded_at
-      attr_reader :file_paths
+    attr_reader :targets
+    attr_reader :base_dir
 
-      def initialize(check:, loaded_at:, file_paths:)
-        @check = check
-        @loaded_at = loaded_at
-        @file_paths = file_paths
-      end
-    end
-
-    class SignatureHasSyntaxError
-      attr_reader :errors
-
-      def initialize(errors:)
-        @errors = errors
-      end
-    end
-
-    class SignatureHasError
-      attr_reader :errors
-
-      def initialize(errors:)
-        @errors = errors
-      end
-    end
-
-    attr_reader :source_files
-    attr_reader :signature_files
-    attr_reader :listener
-
-    attr_reader :signature
-
-    def initialize(listener = nil)
-      @listener = listener || NullListener.new
-      @source_files = {}
-      @signature_files = {}
-    end
-
-    def clear
-      listener.clear_project project: self do
-        @signature = nil
-        source_files.each_value do |file|
-          file.invalidate
-        end
-      end
-    end
+    def initialize(base_dir:)
+      @targets = []
+      @base_dir = base_dir
 
-    def type_check(force_signatures: false, force_sources: false)
-      listener.check(project: self) do
-        should_reload_signature = force_signatures || signature_updated?
-        reload_signature if should_reload_signature
-
-        case sig = signature
-        when SignatureLoaded
-          each_updated_source(force: force_sources || should_reload_signature) do |file|
-            file.invalidate
-
-            listener.parse_source(project: self, file: file) do
-              file.parse()
-            end
-
-            listener.type_check_source(project: self, file: file) do
-              file.type_check(sig.check)
-            end
-          end
-        end
-      end
-    end
-
-    def success?
-      signature.is_a?(SignatureLoaded) &&
-        source_files.all? {|_, file| file.source.is_a?(Source) && file.typing }
-    end
-
-    def has_type_error?
-      source_files.any? do |_, file|
-        file.errors&.any?
-      end
-    end
-
-    def errors
-      source_files.flat_map do |_, file|
-        file.errors || []
-      end
-    end
-
-    # @type method each_updated_source: (?force: bool) ?{ (SourceFile) -> any } -> any
-    def each_updated_source(force: false)
-      if block_given?
-        source_files.each_value do |file|
-          if force || file.requires_type_check?
-            yield file
-          end
-        end
-      else
-        enum_for :each_updated_source, force: force
+      unless base_dir.absolute?
+        raise "Project#initialize(base_dir:): base_dir should be absolute path"
       end
     end
 
-    def signature_updated?
-      case sig = signature
-      when SignatureLoaded
-        signature_files.keys != sig.file_paths ||
-          signature_files.any? {|_, file| file.content_updated_at >= sig.loaded_at }
-      else
-        true
-      end
+    def relative_path(path)
+      path.relative_path_from(base_dir)
     end
 
-    def reload_signature
-      @signature = nil
-
-      env = AST::Signature::Env.new
-      builder = Interface::Builder.new(signatures: env)
-      check = Subtyping::Check.new(builder: builder)
-
-      # @type var syntax_errors: Hash<Pathname, any>
-      syntax_errors = {}
-
-      listener.load_signature(project: self) do
-        signature_files.each_value do |file|
-          sigs = listener.parse_signature(project: self, file: file) do
-            file.parse
-          end
-
-          sigs.each do |sig|
-            env.add sig
-          end
-        rescue Racc::ParseError => exn
-          Steep.logger.warn { "Syntax error on #{file.path}: #{exn.inspect}" }
-          syntax_errors[file.path] = exn
-        end
-
-        if syntax_errors.empty?
-          listener.validate_signature(project: self) do
-            errors = validate_signature(check)
-            @signature = if errors.empty?
-                           SignatureLoaded.new(check: check, loaded_at: Time.now, file_paths: signature_files.keys)
-                         else
-                           SignatureHasError.new(errors: errors)
-                         end
-          end
-        else
-          @signature = SignatureHasSyntaxError.new(errors: syntax_errors)
-        end
-      end
+    def absolute_path(path)
+      (base_dir + path).cleanpath
     end
 
-    def validate_signature(check)
-      errors = []
-
-      builder = check.builder
+    def type_of_node(path:, line:, column:)
+      source_file = targets.map {|target| target.source_files[path] }.compact[0]
 
-      check.builder.signatures.each do |sig|
-        Steep.logger.debug { "Validating signature: #{sig.inspect}" }
+      if source_file
+        case (status = source_file.status)
+        when SourceFile::TypeCheckStatus
+          node = status.source.find_node(line: line, column: column)
 
-        case sig
-        when AST::Signature::Interface
-          yield_self do
-            instance_interface = builder.build_interface(sig.name)
-
-            args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
-            instance_type = AST::Types::Name::Interface.new(name: sig.name, args: args)
-
-            instance_interface.instantiate(type: instance_type,
-                                           args: args,
-                                           instance_type: instance_type,
-                                           module_type: nil).validate(check)
+          type = begin
+            status.typing.type_of(node: node)
+          rescue RuntimeError
+            AST::Builtin.any_type
           end
 
-        when AST::Signature::Module
-          yield_self do
-            instance_interface = builder.build_instance(sig.name)
-            instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
-
-            module_interface = builder.build_module(sig.name)
-            module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
-
-            instance_type = AST::Types::Name::Instance.new(name: sig.name, args: instance_args)
-            module_type = AST::Types::Name::Module.new(name: sig.name)
-
-            Steep.logger.debug { "Validating instance methods..." }
-            instance_interface.instantiate(type: instance_type,
-                                           args: instance_args,
-                                           instance_type: instance_type,
-                                           module_type: module_type).validate(check)
-
-            Steep.logger.debug { "Validating class methods..." }
-            module_interface.instantiate(type: module_type,
-                                         args: module_args,
-                                         instance_type: instance_type,
-                                         module_type: module_type).validate(check)
-          end
-
-        when AST::Signature::Class
-          yield_self do
-            instance_interface = builder.build_instance(sig.name)
-            instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
-
-            module_interface = builder.build_class(sig.name, constructor: true)
-            module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
-
-            instance_type = AST::Types::Name::Instance.new(name: sig.name, args: instance_args)
-            module_type = AST::Types::Name::Class.new(name: sig.name, constructor: true)
-
-            Steep.logger.debug { "Validating instance methods..." }
-            instance_interface.instantiate(type: instance_type,
-                                           args: instance_args,
-                                           instance_type: instance_type,
-                                           module_type: module_type).validate(check)
-
-            Steep.logger.debug { "Validating class methods..." }
-            module_interface.instantiate(type: module_type,
-                                         args: module_args,
-                                         instance_type: instance_type,
-                                         module_type: module_type).validate(check)
-          end
-        end
-
-      rescue => exn
-        errors << exn
-      end
-
-      errors
-    end
-
-    def type_of(path:, line:, column:)
-      if source_file = source_files[path]
-        case source = source_file.source
-        when Source
-          if typing = source_file.typing
-            node = source.find_node(line: line, column: column)
-
-            type = begin
-              typing.type_of(node: node)
-            rescue RuntimeError
-              AST::Builtin.any_type
-            end
-
-            if block_given?
-              yield type, node
-            else
-              type
-            end
+          if block_given?
+            yield type, node
+          else
+            type
           end
         end
       end

data/lib/steep/project/dsl.rb

@@ -0,0 +1,132 @@
+module Steep
+  class Project
+    class DSL
+      class TargetDSL
+        attr_reader :name
+        attr_reader :sources
+        attr_reader :libraries
+        attr_reader :signatures
+        attr_reader :ignored_sources
+        attr_reader :no_builtin
+        attr_reader :vendor_dir
+
+        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [])
+          @name = name
+          @sources = sources
+          @libraries = libraries
+          @signatures = signatures
+          @ignored_sources = ignored_sources
+          @vendor_dir = nil
+        end
+
+        def initialize_copy(other)
+          @name = other.name
+          @sources = other.sources.dup
+          @libraries = other.libraries.dup
+          @signatures = other.signatures.dup
+          @ignored_sources = other.ignored_sources.dup
+          @vendor_dir = other.vendor_dir
+        end
+
+        def check(*args)
+          sources.push(*args)
+        end
+
+        def ignore(*args)
+          ignored_sources.push(*args)
+        end
+
+        def library(*args)
+          libraries.push(*args)
+        end
+
+        def signature(*args)
+          signatures.push(*args)
+        end
+
+        def update(name: self.name, sources: self.sources, libraries: self.libraries, ignored_sources: self.ignored_sources, signatures: self.signatures)
+          self.class.new(
+            name,
+            sources: sources,
+            libraries: libraries,
+            signatures: signatures,
+            ignored_sources: ignored_sources
+          )
+        end
+
+        def no_builtin!(value = true)
+          Steep.logger.error "`no_builtin!` in Steepfile is deprecated and ignored. Use `vendor` instead."
+        end
+
+        def vendor(dir = "vendor/sigs", stdlib: nil, gems: nil)
+          if stdlib || gems
+            @vendor_dir = [
+              stdlib&.yield_self {|x| Pathname(x) },
+              gems&.yield_self {|x| Pathname(x) }
+            ]
+          else
+            @vendor_dir = Pathname(dir)
+          end
+        end
+      end
+
+      attr_reader :project
+
+      @@templates = {
+        gemfile: TargetDSL.new(:gemfile).tap do |target|
+          target.check "Gemfile"
+          target.library "gemfile"
+        end
+      }
+
+      def self.templates
+        @@templates
+      end
+
+      def initialize(project:)
+        @project = project
+        @global_signatures = []
+      end
+
+      def self.register_template(name, target)
+        templates[name] = target
+      end
+
+      def self.parse(project, code, filename: "Steepfile")
+        self.new(project: project).instance_eval(code, filename)
+      end
+
+      def target(name, template: nil, &block)
+        target = if template
+                   self.class.templates[template]&.dup&.update(name: name) or
+                     raise "Unknown template: #{template}, available templates: #{@@templates.keys.join(", ")}"
+                 else
+                   TargetDSL.new(name)
+                 end
+
+        target.instance_eval(&block) if block_given?
+
+        Project::Target.new(
+          name: target.name,
+          source_patterns: target.sources,
+          ignore_patterns: target.ignored_sources,
+          signature_patterns: target.signatures,
+          options: Options.new.tap do |options|
+            options.libraries.push(*target.libraries)
+
+            case target.vendor_dir
+            when Array
+              options.vendored_stdlib_path = target.vendor_dir[0]
+              options.vendored_gems_path = target.vendor_dir[1]
+            when Pathname
+              options.vendored_stdlib_path = target.vendor_dir + "stdlib"
+              options.vendored_gems_path = target.vendor_dir + "gems"
+            end
+          end
+        ).tap do |target|
+          project.targets << target
+        end
+      end
+    end
+  end
+end

data/lib/steep/project/file.rb

@@ -1,101 +1,108 @@
 module Steep
   class Project
     class SourceFile
-      attr_reader :options
       attr_reader :path
       attr_reader :content
       attr_reader :content_updated_at
+      attr_reader :factory
 
-      attr_reader :source
-      attr_reader :typing
-      attr_reader :last_type_checked_at
+      attr_accessor :status
 
-      def initialize(path:, options:)
+      ParseErrorStatus = Struct.new(:error, keyword_init: true)
+      AnnotationSyntaxErrorStatus = Struct.new(:error, :location, keyword_init: true)
+      TypeCheckStatus = Struct.new(:typing, :source, :timestamp, keyword_init: true)
+
+      def initialize(path:)
         @path = path
-        @options = options
+        @content = false
         self.content = ""
       end
 
       def content=(content)
-        @content_updated_at = Time.now
-        @content = content
-      end
-
-      def requires_type_check?
-        if last = last_type_checked_at
-          last < content_updated_at
-        else
-          true
+        if @content != content
+          @content_updated_at = Time.now
+          @content = content
+          @status = nil
         end
       end
 
-      def invalidate
-        @source = nil
-        @typing = nil
-        @last_type_checked_at = nil
-      end
-
-      def parse
-        _ = @source =
-          begin
-            Source.parse(content, path: path.to_s, labeling: ASTUtils::Labeling.new)
-          rescue ::Parser::SyntaxError => exn
-            Steep.logger.warn { "Syntax error on #{path}: #{exn.inspect}" }
-            exn
-          rescue EncodingError => exn
-            Steep.logger.warn { "Encoding error on #{path}: #{exn.inspect}" }
-            exn
-          end
-      end
-
       def errors
-        typing&.errors&.reject do |error|
-          case
-          when error.is_a?(Errors::FallbackAny)
-            !options.fallback_any_is_error
-          when error.is_a?(Errors::MethodDefinitionMissing)
-            options.allow_missing_definitions
-          end
+        case status
+        when TypeCheckStatus
+          status.typing.errors
+          # errors.reject do |error|
+          #   case
+          #   when error.is_a?(Errors::FallbackAny)
+          #     !options.fallback_any_is_error
+          #   when error.is_a?(Errors::MethodDefinitionMissing)
+          #     options.allow_missing_definitions
+          #   end
+          # end
+        else
+          []
         end
       end
 
-      def type_check(check)
-        case source = self.source
-        when Source
-          @typing = Typing.new
-
-          annotations = source.annotations(block: source.node, builder: check.builder, current_module: AST::Namespace.root)
-
-          const_env = TypeInference::ConstantEnv.new(builder: check.builder, context: nil)
-          type_env = TypeInference::TypeEnv.build(annotations: annotations,
-                                                  subtyping: check,
-                                                  const_env: const_env,
-                                                  signatures: check.builder.signatures)
+      def type_check(subtyping, env_updated_at)
+        # skip type check
+        return false if status.is_a?(TypeCheckStatus) && env_updated_at <= status.timestamp
+
+        parse(subtyping.factory) do |source|
+          typing = Typing.new
+
+          if source
+            annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
+            const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: nil)
+            type_env = TypeInference::TypeEnv.build(annotations: annotations,
+                                                    subtyping: subtyping,
+                                                    const_env: const_env,
+                                                    signatures: subtyping.factory.env)
+
+            construction = TypeConstruction.new(
+              checker: subtyping,
+              annotations: annotations,
+              source: source,
+              self_type: AST::Builtin::Object.instance_type,
+              block_context: nil,
+              module_context: TypeConstruction::ModuleContext.new(
+                instance_type: nil,
+                module_type: nil,
+                implement_name: nil,
+                current_namespace: AST::Namespace.root,
+                const_env: const_env,
+                class_name: nil
+              ),
+              method_context: nil,
+              typing: typing,
+              break_context: nil,
+              type_env: type_env
+            )
+
+            construction.synthesize(source.node)
+          end
 
-          construction = TypeConstruction.new(
-            checker: check,
-            annotations: annotations,
-            source: source,
-            self_type: AST::Builtin::Object.instance_type,
-            block_context: nil,
-            module_context: TypeConstruction::ModuleContext.new(
-              instance_type: nil,
-              module_type: nil,
-              implement_name: nil,
-              current_namespace: AST::Namespace.root,
-              const_env: const_env,
-              class_name: nil
-            ),
-            method_context: nil,
+          @status = TypeCheckStatus.new(
             typing: typing,
-            break_context: nil,
-            type_env: type_env
+            source: source,
+            timestamp: Time.now
           )
+        end
 
-          construction.synthesize(source.node)
+        true
+      end
 
-          @last_type_checked_at = Time.now
+      def parse(factory)
+        if status.is_a?(TypeCheckStatus)
+          yield status.source
+        else
+          yield Source.parse(content, path: path.to_s, factory: factory, labeling: ASTUtils::Labeling.new)
         end
+      rescue AnnotationParser::SyntaxError => exn
+        Steep.logger.warn { "Annotation syntax error on #{path}: #{exn.inspect}" }
+        @status = AnnotationSyntaxErrorStatus.new(error: exn, location: exn.location)
+      rescue ::Parser::SyntaxError, EncodingError => exn
+        Steep.logger.warn { "Source parsing error on #{path}: #{exn.inspect}" }
+        @status = ParseErrorStatus.new(error: exn)
       end
     end
 
@@ -104,18 +111,28 @@ module Steep
       attr_reader :content
       attr_reader :content_updated_at
 
+      attr_reader :status
+
+      ParseErrorStatus = Struct.new(:error, keyword_init: true)
+      DeclarationsStatus = Struct.new(:declarations, keyword_init: true)
+
       def initialize(path:)
         @path = path
         self.content = ""
       end
 
-      def parse
-        Parser.parse_signature(content, name: path)
-      end
-
       def content=(content)
         @content_updated_at = Time.now
         @content = content
+        @status = nil
+      end
+
+      def load!
+        buffer = Ruby::Signature::Buffer.new(name: path, content: content)
+        decls = Ruby::Signature::Parser.parse_signature(buffer)
+        @status = DeclarationsStatus.new(declarations: decls)
+      rescue Ruby::Signature::Parser::SyntaxError, Ruby::Signature::Parser::SemanticsError => exn
+        @status = ParseErrorStatus.new(error: exn)
       end
     end
   end