steep 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2c1abcf64958fd547dbb336a0489d9e310e71bc66d208a67c6328c1ac09e62b
-  data.tar.gz: eecd4d437442a85356525c31d10697d73f06fd319930371a7f2710b77f3e86a3
+  metadata.gz: 566e77aa4db03cb06ae80569f4db9f5409e65199b1af4af9fc6f2598e911f694
+  data.tar.gz: 41f1d54c5196fdec7cc58751899aec208066d845eef717234bb37266313c7d8d
 SHA512:
-  metadata.gz: 57957103491d678aa843f9155a757d9f903968d272e2d117b659bcb46659ada397cf82db1bf4e54e25f77a5548db32b6ea2da7be0fba6920d033340c44448c19
-  data.tar.gz: 94eeb79af2e1fdab28b5f2c6237e343d9f174d7ff5a65c9d25d3860e042820027c1f4fab8c6571492967c74b37161572b8ab1dea91d8d60d0e7f2c1cbf4c31fe
+  metadata.gz: 46366ed11a6328a6a237c52042ef49eb12d5ce3db111fb55c5038109b62aa471ba6634c8c060575f6862658dcc0f388684a083f9a691becd6d90f076acb05908
+  data.tar.gz: 9cb15861e6de6b5209dd82745f1c7cf67c212e3e15cc9c1f92956b84089801f994c7c1cd79ff8972f37da229530e7354d237ce4a74ce844083daf656936286dc

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 0.20.0 (2020-07-17)
+
+* Support singleton class definitions ([#166](https://github.com/soutaro/steep/pull/166))
+
 ## 0.19.0 (2020-07-12)
 
 * Update RBS. ([#157](https://github.com/soutaro/steep/pull/157))

data/lib/steep/type_construction.rb

@@ -230,6 +230,39 @@ module Steep
       )
     end
 
+    def implement_module(module_name:, super_name: nil, annotations:)
+      if (annotation = annotations.implement_module_annotation)
+        absolute_name(annotation.name.name).yield_self do |absolute_name|
+          if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+            AST::Annotation::Implements::Module.new(
+              name: absolute_name,
+              args: annotation.name.args
+            )
+          else
+            Steep.logger.error "Unknown class name given to @implements: #{annotation.name.name}"
+            nil
+          end
+        end
+      else
+        name = nil
+        name ||= absolute_name(module_name).yield_self do |absolute_name|
+          absolute_name if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+        end
+        name ||= super_name && absolute_name(super_name).yield_self do |absolute_name|
+          absolute_name if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+        end
+
+        if name
+          absolute_name_ = checker.factory.type_name_1(name)
+          entry = checker.factory.env.class_decls[absolute_name_]
+          AST::Annotation::Implements::Module.new(
+            name: name,
+            args: entry.type_params.each.map(&:name)
+          )
+        end
+      end
+    end
+
     def for_module(node)
       new_module_name = Names::Module.from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
       new_namespace = nested_namespace_for_module(new_module_name)
@@ -240,28 +273,7 @@ module Steep
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
       module_type = AST::Builtin::Module.instance_type
 
-      implement_module_name = yield_self do
-        if (annotation = annots.implement_module_annotation)
-          absolute_name(annotation.name.name).yield_self do |absolute_name|
-            if checker.factory.module_name?(absolute_name)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: annotation.name.args)
-            else
-              Steep.logger.error "Unknown module name given to @implements: #{annotation.name.name}"
-              nil
-            end
-          end
-        else
-          absolute_name(new_module_name).yield_self do |absolute_name|
-            if checker.factory.module_name?(absolute_name)
-              absolute_name_ = checker.factory.type_name_1(absolute_name)
-              entry = checker.factory.env.class_decls[absolute_name_]
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: entry.type_params.each.map(&:name))
-            end
-          end
-        end
-      end
+      implement_module_name = implement_module(module_name: new_module_name, annotations: annots)
 
       if implement_module_name
         module_name = implement_module_name.name
@@ -352,36 +364,7 @@ module Steep
 
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
 
-      implement_module_name = yield_self do
-        if (annotation = annots.implement_module_annotation)
-          absolute_name(annotation.name.name).yield_self do |absolute_name|
-            if checker.factory.class_name?(absolute_name)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: annotation.name.args)
-            else
-              Steep.logger.error "Unknown class name given to @implements: #{annotation.name.name}"
-              nil
-            end
-          end
-        else
-          name = nil
-          name ||= absolute_name(new_class_name).yield_self do |absolute_name|
-            absolute_name if checker.factory.class_name?(absolute_name)
-          end
-          name ||= super_class_name && absolute_name(super_class_name).yield_self do |absolute_name|
-            absolute_name if checker.factory.class_name?(absolute_name)
-          end
-
-          if name
-            absolute_name_ = checker.factory.type_name_1(name)
-            entry = checker.factory.env.class_decls[absolute_name_]
-            AST::Annotation::Implements::Module.new(
-              name: name,
-              args: entry.type_params.each.map(&:name)
-            )
-          end
-        end
-      end
+      implement_module_name = implement_module(module_name: new_class_name, super_name: super_class_name, annotations: annots)
 
       if annots.implement_module_annotation
         new_class_name = implement_module_name.name
@@ -450,6 +433,83 @@ module Steep
       )
     end
 
+    def for_sclass(node, type)
+      annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
+
+      instance_type = if type.is_a?(AST::Types::Self)
+                        context.self_type
+                      else
+                        type
+                      end
+
+      module_type = case instance_type
+                    when AST::Types::Name::Class
+                      AST::Builtin::Class.instance_type
+                    when AST::Types::Name::Module
+                      AST::Builtin::Module.instance_type
+                    when AST::Types::Name::Instance
+                      instance_type.to_class(constructor: nil)
+                    else
+                      raise "Unexpected type for sclass node: #{type}"
+                    end
+
+      instance_definition = case instance_type
+                            when AST::Types::Name::Class, AST::Types::Name::Module
+                              type_name = checker.factory.type_name_1(instance_type.name)
+                              checker.factory.definition_builder.build_singleton(type_name)
+                            when AST::Types::Name::Instance
+                              type_name = checker.factory.type_name_1(instance_type.name)
+                              checker.factory.definition_builder.build_instance(type_name)
+                            end
+
+      module_definition = case module_type
+                          when AST::Types::Name::Class, AST::Types::Name::Module
+                            type_name = checker.factory.type_name_1(instance_type.name)
+                            checker.factory.definition_builder.build_singleton(type_name)
+                          else
+                            nil
+                          end
+
+      module_context = TypeInference::Context::ModuleContext.new(
+        instance_type: annots.instance_type || instance_type,
+        module_type: annots.self_type || annots.module_type || module_type,
+        implement_name: nil,
+        current_namespace: current_namespace,
+        const_env: self.module_context.const_env,
+        class_name: self.module_context.class_name,
+        module_definition: module_definition,
+        instance_definition: instance_definition
+      )
+
+      type_env = TypeInference::TypeEnv.build(annotations: annots,
+                                              subtyping: checker,
+                                              const_env: self.module_context.const_env,
+                                              signatures: checker.factory.env)
+
+      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
+        subtyping: checker,
+        self_type: module_context.module_type
+      ).annotate(annots)
+
+      body_context = TypeInference::Context.new(
+        method_context: nil,
+        block_context: nil,
+        module_context: module_context,
+        break_context: nil,
+        self_type: module_context.module_type,
+        type_env: type_env,
+        lvar_env: lvar_env
+      )
+
+      self.class.new(
+        checker: checker,
+        source: source,
+        annotations: annots,
+        typing: typing,
+        context: body_context
+      )
+    end
+
     def for_branch(node, truthy_vars: Set.new, type_case_override: nil, break_context: context.break_context)
       annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
 
@@ -1130,6 +1190,25 @@ module Steep
             add_typing(node, type: AST::Builtin.nil_type)
           end
 
+        when :sclass
+          yield_self do
+            type, constr = synthesize(node.children[0])
+            constructor = constr.for_sclass(node, type)
+
+            constructor.typing.add_context_for_node(node, context: constructor.context)
+            constructor.typing.add_context_for_body(node, context: constructor.context)
+
+            constructor.synthesize(node.children[1]) if node.children[1]
+
+            if constructor.module_context.instance_definition && module_context.module_definition
+              if constructor.module_context.instance_definition.type_name == module_context.module_definition.type_name
+                module_context.defined_module_methods.merge(constructor.module_context.defined_instance_methods)
+              end
+            end
+
+            add_typing(node, type: AST::Builtin.nil_type)
+          end
+
         when :self
           add_typing node, type: AST::Types::Self.new
 

data/lib/steep/typing.rb

@@ -95,6 +95,12 @@ module Steep
         end_pos = node.loc.end.begin_pos
         add_context(begin_pos..end_pos, context: context)
 
+      when :sclass
+        name_node = node.children[0]
+        begin_pos = name_node.loc.expression.end_pos
+        end_pos = node.loc.end.begin_pos
+        add_context(begin_pos..end_pos, context: context)
+
       when :def, :defs
         args_node = case node.type
                     when :def

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.19.0"
+  VERSION = "0.20.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-12 00:00:00.000000000 Z
+date: 2020-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler