lib/rbs/definition.rb in rbs-0.11.0 vs lib/rbs/definition.rb in rbs-0.12.0

@@ -45,13 +45,13 @@
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)
           TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in)
         end
 
         def overload?
-          case member
+          case mem = member
           when AST::Members::MethodDefinition
-            member.overload?
+            mem.overload?
           else
             false
           end
         end
       end
@@ -67,23 +67,29 @@
         @accessibility = accessibility
         @extra_annotations = annotations
       end
 
       def defined_in
-        @defined_in ||= defs.last.defined_in
+        @defined_in ||= begin
+          last_def = defs.last or raise
+          last_def.defined_in
+        end
       end
 
       def implemented_in
-        @implemented_in ||= defs.last.implemented_in
+        @implemented_in ||= begin
+          last_def = defs.last or raise
+          last_def.implemented_in
+        end
       end
 
       def method_types
         @method_types ||= defs.map(&:type)
       end
 
       def comments
-        @comments ||= defs.map(&:comment).compact
+        @comments ||= _ = defs.map(&:comment).compact
       end
 
       def annotations
         @annotations ||= @extra_annotations + defs.flat_map(&:annotations)
       end
@@ -124,12 +130,12 @@
         )
       end
     end
 
     module Ancestor
-      Instance = Struct.new(:name, :args, keyword_init: true)
-      Singleton = Struct.new(:name, keyword_init: true)
+      Instance = _ = Struct.new(:name, :args, keyword_init: true)
+      Singleton = _ = Struct.new(:name, keyword_init: true)
     end
 
     class InstanceAncestors
       attr_reader :type_name
       attr_reader :params
@@ -217,11 +223,14 @@
     def module?
       entry.is_a?(Environment::ModuleEntry)
     end
 
     def interface?
-      entry.is_a?(Environment::SingleEntry) && entry.decl.is_a?(AST::Declarations::Interface)
+      case en = entry
+      when Environment::SingleEntry
+        en.decl.is_a?(AST::Declarations::Interface)
+      end
     end
 
     def class_type?
       self_type.is_a?(Types::ClassSingleton)
     end
@@ -237,20 +246,20 @@
     def type_params
       type_params_decl.each.map(&:name)
     end
 
     def type_params_decl
-      case entry
+      case en = entry
       when Environment::ClassEntry, Environment::ModuleEntry
-        entry.type_params
+        en.type_params
       when Environment::SingleEntry
-        entry.decl.type_params
+        en.decl.type_params
       end
     end
 
     def sub(s)
-      definition = self.class.new(type_name: type_name, self_type: self_type.sub(s), ancestors: ancestors, entry: entry)
+      definition = self.class.new(type_name: type_name, self_type: _ = self_type.sub(s), ancestors: ancestors, entry: entry)
 
       definition.methods.merge!(methods.transform_values {|method| method.sub(s) })
       definition.instance_variables.merge!(instance_variables.transform_values {|v| v.sub(s) })
       definition.class_variables.merge!(class_variables.transform_values {|v| v.sub(s) })
 
@@ -266,10 +275,10 @@
 
       definition
     end
 
     def each_type(&block)
-      if block_given?
+      if block
         methods.each_value do |method|
           if method.defined_in == type_name
             method.method_types.each do |method_type|
               method_type.each_type(&block)
             end