rdl 2.1.0 → 2.2.0

data/lib/rdl/types/var.rb

@@ -57,5 +57,15 @@ module RDL::Type
       return inst[@name] if inst[@name]
       return self
     end
+
+    def widen
+      return inst[@name] if inst[@name]
+      return self
+    end
+
+    def copy
+      self
+    end
+
   end
 end

data/lib/rdl/types/vararg.rb

@@ -53,6 +53,14 @@ module RDL::Type
       return VarargType.new(@type.instantiate(inst))
     end
 
+    def widen
+      return VarargType.new(@type.widen)
+    end
+
+    def copy
+      return VarargType.new(@type.copy)
+    end
+
     def hash # :nodoc:
       return 59 + @type.hash
     end

data/lib/rdl/util.rb

@@ -60,20 +60,15 @@ class RDL::Util
     begin
       sk = self.to_class klass
       msym = method.to_sym
-      mstr = method.to_s
-      sk.instance_method msym
     rescue NameError
       return false
     end
-    klass_str = RDL::Util.to_class_str(klass).hash
-    if mstr.start_with?('__rdl') and mstr.end_with?('_old_#{klass_str}')
-      mstr0 = RDL::Wrap.unwrapped_name(klass, mstr)
-      owner0 = sk.instance_method(mstr0).owner
-      owner = sk.instance_method(mstr).owner
-      return false if owner0 != owner
-    end
 
-    true
+    return sk.methods.include?(:new) if method == :new
+
+    sk.public_instance_methods(false).include?(msym) or
+      sk.protected_instance_methods(false).include?(msym) or
+      sk.private_instance_methods(false).include?(msym)
   end
 
   # Returns the @__rdl_type field of [+obj+]
@@ -93,4 +88,12 @@ class RDL::Util
       klass + "#" + meth.to_s
     end
   end
+
+  def self.silent_warnings
+    old_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+  ensure
+    $stderr = old_stderr
+  end
 end

data/lib/rdl/wrap.rb

@@ -68,7 +68,13 @@ class RDL::Wrap
             posts = RDL::Globals.info.get(klass, meth, :post)
             RDL::Contract::AndContract.check_array(posts, self, ret, *args, &blk) if posts
             if matches
-              ret = RDL::Type::MethodType.check_ret_types(self, "#{full_method_name}", types, inst, matches, ret, bind, *args, &blk)
+              if meth.to_sym == :initialize
+                types.each { |t|
+                  raise ArgumentError, "Initialize method must be annotated with return type `self` or a generic type where base is `self`. #{full_method_name} has incorrect type." unless ((t.ret.is_a?(RDL::Type::VarType) && t.ret.name == :self) || (t.ret.is_a?(RDL::Type::GenericType) && t.ret.base.is_a?(RDL::Type::VarType) && t.ret.base.name == :self))
+                }
+              else
+                ret = RDL::Type::MethodType.check_ret_types(self, "#{full_method_name}", types, inst, matches, ret, bind, *args, &blk) unless (meth.to_sym == :initialize)
+              end
             end
             if RDL::Config.instance.guess_types.include?("#{klass_str_without_singleton}".to_sym)
               RDL::Globals.info.add(klass, meth, :otype, { args: (args.map { |arg| arg.class }), ret: ret.class, block: block_given? })
@@ -151,13 +157,13 @@ RUBY
     "__rdl_#{meth.to_s}_old_#{klass_str}".to_sym
   end
 
-  def self.unwrapped_name(s)
-    if not s.start_with?('__rdl_') and s.include?('_old_')
-      raise Exception, "cannot get unwrapped name for #{s}"
+  def self.unwrapped_name(klass, meth_str)
+    if not meth_str.start_with?('__rdl_') and meth_str.include?('_old_')
+      raise Exception, "cannot get unwrapped name for #{meth_str}"
     end
     klass_str = RDL::Util.to_class_str(klass).hash.to_s
-    s = klass_str.split("_#{klass_str}")
-    s[6..-5]
+    meth_str = meth_str.split("_#{klass_str}")[0]
+    meth_str[6..-5]
   end
 
   def self.class_to_string(klass)
@@ -213,6 +219,7 @@ RUBY
           raise RuntimeError, "Deferred #{kind} contract from class #{prev_klass} being applied in class #{tmp_klass} to #{meth}"
         end
         RDL::Globals.info.add(klass, meth, kind, contract)
+        RDL::Globals.info.add(klass, meth, :effect, h[:effect]) if h.has_key?(:effect)
         RDL::Wrap.wrap(klass, meth) if h[:wrap]
         unless !h.has_key?(:typecheck) || RDL::Globals.info.set(klass, meth, :typecheck, h[:typecheck])
           raise RuntimeError, "Inconsistent typecheck flag on #{RDL::Util.pp_klass_method(klass, meth)}"
@@ -317,7 +324,7 @@ module RDL::Annotate
   # type(klass, meth, type)
   # type(meth, type)
   # type(type)
-  def type(*args, wrap: RDL::Config.instance.type_defaults[:wrap], typecheck: RDL::Config.instance.type_defaults[:typecheck], version: nil)
+  def type(*args, wrap: RDL::Config.instance.type_defaults[:wrap], typecheck: RDL::Config.instance.type_defaults[:typecheck], version: nil, effect: nil)
     return if version && !(Gem::Requirement.new(version).satisfied_by? Gem.ruby_version)
     klass, meth, type = begin
                           RDL::Wrap.process_type_args(self, *args)
@@ -331,12 +338,20 @@ module RDL::Annotate
                           err.set_backtrace bt
                           raise err
                         end
+    effect[0] = :- if effect && effect[0] == :~ ## For now, treating pure-ish :~ as :-, since we realized it doesn't actually affect termination checking.
+    typs = type.args + [type.ret]
+    if type.block
+      block_type = type.block.is_a?(RDL::Type::OptionalType) ? type.block.type : type.block
+      typs = typs + block_type.args + [block_type.ret]
+    end
+    RDL::Globals.dep_types << [klass, meth, type] if typs.any? { |t| t.is_a?(RDL::Type::ComputedType) || (t.is_a?(RDL::Type::BoundArgType) && t.type.is_a?(RDL::Type::ComputedType)) }
     if meth
 # It turns out Ruby core/stdlib don't always follow this convention...
 #        if (meth.to_s[-1] == "?") && (type.ret != RDL::Globals.types[:bool])
 #          warn "#{RDL::Util.pp_klass_method(klass, meth)}: methods that end in ? should have return type %bool"
 #        end
       RDL::Globals.info.add(klass, meth, :type, type)
+      RDL::Globals.info.add(klass, meth, :effect, effect)
       unless RDL::Globals.info.set(klass, meth, :typecheck, typecheck)
         raise RuntimeError, "Inconsistent typecheck flag on #{RDL::Util.pp_klass_method(klass, meth)}"
       end
@@ -351,29 +366,30 @@ module RDL::Annotate
           end
           RDL::Wrap.wrap(klass, meth) if wrap
         else
-          if wrap
-            RDL::Globals.to_wrap << [klass, meth]
-            if (typecheck && typecheck != :call)
-              RDL::Globals.to_typecheck[typecheck] = Set.new unless RDL::Globals.to_typecheck[typecheck]
-              RDL::Globals.to_typecheck[typecheck].add([klass, meth])
-            end
+          RDL::Globals.to_wrap << [klass, meth] if wrap
+          if (typecheck && typecheck != :call)
+            RDL::Globals.to_typecheck[typecheck] = Set.new unless RDL::Globals.to_typecheck[typecheck]
+            RDL::Globals.to_typecheck[typecheck].add([klass, meth])
           end
         end
       end
     else
       RDL::Globals.deferred << [klass, :type, type, {wrap: wrap,
-                                               typecheck: typecheck}]
+                                               typecheck: typecheck, effect: effect}]
     end
     nil
   end
 
+  def readd_comp_types
+    RDL::Globals.dep_types.each { |klass, meth, t| RDL::Globals.info.add(klass, meth, :type, t) unless meth.nil? }
+  end
+
   # [+ klass +] is the class containing the variable; self if omitted; ignored for local and global variables
   # [+ var +] is a symbol or string containing the name of the variable
   # [+ typ +] is a string containing the type
   def var_type(klass=self, var, typ)
     raise RuntimeError, "Variable cannot begin with capital" if var.to_s =~ /^[A-Z]/
     return if var.to_s =~ /^[a-z]/ # local variables handled specially, inside type checker
-    raise RuntimeError, "Global variables can't be typed in a class" unless klass = self
     klass = RDL::Util::GLOBAL_NAME if var.to_s =~ /^\$/
     unless RDL::Globals.info.set(klass, var, :type, RDL::Globals.parser.scan_str("#T #{typ}"))
       raise RuntimeError, "Type already declared for #{var}"
@@ -385,6 +401,7 @@ module RDL::Annotate
   # [+ args +] is a sequence of symbol, typ. attr_reader is called for each symbol,
   # and var_type is called to assign the immediately following type to the
   # attribute named after that symbol.
+  # Note these three methods are duplicated in RDLAnnotate
   def attr_accessor_type(*args)
     args.each_slice(2) { |name, typ|
       attr_accessor name
@@ -496,12 +513,40 @@ module RDL::RDLAnnotate
   define_method :rdl_post, RDL::Annotate.instance_method(:post)
   define_method :rdl_type, RDL::Annotate.instance_method(:type)
   define_method :rdl_var_type, RDL::Annotate.instance_method(:var_type)
-  define_method :rdl_attr_accessor_type, RDL::Annotate.instance_method(:attr_accessor_type)
-  define_method :rdl_attr_reader_type, RDL::Annotate.instance_method(:attr_reader_type)
-  define_method :rdl_attr_type, RDL::Annotate.instance_method(:attr_type)
-  define_method :rdl_attr_writer_type, RDL::Annotate.instance_method(:attr_writer_type)
   define_method :rdl_alias, RDL::Annotate.instance_method(:rdl_alias)
   define_method :rdl_type_params, RDL::Annotate.instance_method(:type_params)
+
+  # Need to duplicate these methods because they need to call rdl_var_type and rdl_type
+  # and couldn't figure out how to do instance_method with a partial argument binding
+  def rdl_attr_accessor_type(*args)
+    args.each_slice(2) { |name, typ|
+      attr_accessor name
+      rdl_var_type ("@" + name.to_s), typ
+      rdl_type name, "() -> #{typ}"
+      rdl_type name.to_s + "=", "(#{typ}) -> #{typ}"
+    }
+    nil
+  end
+
+  def rdl_attr_reader_type(*args)
+    args.each_slice(2) { |name, typ|
+      attr_reader name
+      rdl_var_type ("@" + name.to_s), typ
+      rdl_type name, "() -> #{typ}"
+    }
+    nil
+  end
+
+  alias_method :rdl_attr_type, :rdl_attr_reader_type
+
+  def rdl_attr_writer_type(*args)
+    args.each_slice(2) { |name, typ|
+      attr_writer name
+      rdl_var_type ("@" + name.to_s), typ
+      rdl_type name.to_s + "=", "(#{typ}) -> #{typ}"
+    }
+    nil
+  end
 end
 
 module RDL
@@ -553,6 +598,146 @@ module RDL
     nil
   end
 
+  def self.load_sequel_schema(db)
+    db.tables.each { |table|
+      hash_str = "{ "
+      kl_name = table.to_s.camelize.singularize
+      db.schema(table).each { |col|
+        hash_str << "#{col[0]}: "
+        typ = col[1][:type].to_s.camelize
+        if typ == "Datetime"
+          typ = "DateTime or Time" ## Sequel accepts both
+        elsif typ == "Boolean"
+          typ = "%bool"
+        elsif typ == "Text"
+          typ = "String"
+        end
+        hash_str << "#{typ},"
+        RDL.type kl_name, col[0], "() -> #{typ}", wrap: false
+        RDL.type kl_name, "#{col[0]}=", "(#{typ}) -> #{typ}", wrap: false
+      }
+      hash_str.chomp!(",") << " }"
+      RDL::Globals.seq_db_schema[table] = RDL::Globals.parser.scan_str "#T #{hash_str}"
+    }
+  end
+
+  def self.load_rails_schema
+    return unless defined?(Rails)
+    ::Rails.application.eager_load! # load Rails app
+    models = ActiveRecord::Base.descendants.each { |m|
+      begin
+        ## load schema for each Rails model
+        m.send(:load_schema) unless m.abstract_class?
+      rescue
+      end }
+
+    models.each { |model|
+      next if model.to_s == "ApplicationRecord"
+      next if model.to_s == "GroupManager"
+      RDL.nowrap model
+      s1 = {}
+      model.columns_hash.each { |k, v| t_name = v.type.to_s.camelize
+        ## Map SQL column types to the corresponding RDL type
+        if t_name == "Boolean"
+          t_name = "%bool"
+          s1[k] = RDL::Globals.types[:bool]
+        elsif t_name == "Datetime"
+          t_name = "DateTime or Time"
+          s1[k] = RDL::Type::UnionType.new(RDL::Type::NominalType.new(Time), RDL::Type::NominalType.new(DateTime))
+        elsif t_name == "Text"
+          ## difference between `text` and `string` is in the SQL types they're mapped to, not in Ruby types
+          t_name = "String"
+          s1[k] = RDL::Globals.types[:string]
+        else
+          s1[k] = RDL::Type::NominalType.new(t_name)
+        end
+        RDL.type model, (k+"=").to_sym, "(#{t_name}) -> #{t_name}", wrap: false ## create method type for column setter
+        RDL.type model, (k).to_sym, "() -> #{t_name}", wrap: false ## create method type for column getter
+      }
+      s2 = s1.transform_keys { |k| k.to_sym }
+      assoc = {}
+      model.reflect_on_all_associations.each { |a|
+        ## Generate method types based on associations
+        add_ar_assoc(assoc, a.macro, a.name)
+        if a.name.to_s.pluralize == a.name.to_s ## plural association
+          ## This actually returns an Associations CollectionProxy, which is a descendant of ActiveRecord_Relation (see below actual type). This makes no difference in practice.
+          RDL.type model, a.name, "() -> ActiveRecord_Relation<#{a.name.to_s.camelize.singularize}>", wrap: false
+          #ActiveRecord_Associations_CollectionProxy<#{a.name.to_s.camelize.singularize}>'
+        else
+          ## association is singular, we just return an instance of associated class
+          RDL.type model, a.name, "() -> #{a.name.to_s.camelize.singularize}", wrap: false
+        end
+      }
+      s2[:__associations] = RDL::Type::FiniteHashType.new(assoc, nil)
+      base_name = model.to_s
+      base_type = RDL::Type::NominalType.new(model.to_s)
+      hash_type = RDL::Type::FiniteHashType.new(s2, nil)
+      schema = RDL::Type::GenericType.new(base_type, hash_type)
+      RDL::Globals.ar_db_schema[base_name.to_sym] = schema
+    }
+  end
+
+  def self.check_type_code
+    RDL.config { |config| config.use_comp_types = false }
+    count = 1
+    #code_type = RDL::Globals.parser.scan_str "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type"
+    RDL::Globals.dep_types.each { |klass, meth, typ|
+      klass = RDL::Util.has_singleton_marker(klass) ? RDL::Util.remove_singleton_marker(klass) : klass
+      arg_list = "(trec, targs"
+      type_list = "(RDL::Type::Type, Array<RDL::Type::Type>"
+      (typ.args+[typ.ret]+[typ.block]).each { |t|
+        ## First collect all bindings to be used during type checking.
+        if (t.is_a?(RDL::Type::BoundArgType))
+          arg_list << ", #{t.name}"
+          type_list << ", #{t.type.class}"
+        end
+      }
+      arg_list << ")"
+      type_list << ")"
+      code_type = RDL::Globals.parser.scan_str "#{type_list} -> RDL::Type::Type"
+      (typ.args+[typ.ret]+[typ.block]).each { |t|
+        if t.is_a?(RDL::Type::ComputedType)
+          meth = cleanse_meth_name(meth)
+          if klass.to_s.include?("::") ## hacky way around namespace issue
+            tmp_meth =  "def klass.tc_#{meth}#{count}#{arg_list} #{t.code}; end"
+            tmp_eval = "klass = #{klass} ; #{tmp_meth}"
+          else
+            tmp_meth = tmp_eval = "def #{klass}.tc_#{meth}#{count}#{arg_list} #{t.code}; end"
+          end
+          eval tmp_eval
+          ast = Parser::CurrentRuby.parse tmp_meth
+          RDL::Typecheck.typecheck("[s]#{klass}", "tc_#{meth}#{count}".to_sym, ast, [code_type], [[:-, :+]]) 
+          count += 1
+        end
+      }
+    }
+    RDL.do_typecheck :type_code
+    RDL.config { |config| config.use_comp_types = true }
+    true
+  end
+
+  def self.cleanse_meth_name(meth)
+    meth = meth.to_s
+    meth.gsub!("%", "percent")
+    meth.gsub!("&", "ampersand")
+    meth.gsub!("*", "asterisk")
+    meth.gsub!("+", "plus")
+    meth.gsub!("-", "dash")
+    meth.gsub!("@", "at")
+    meth.gsub!("/", "slash")
+    meth.gsub!("<", "lt")
+    meth.gsub!(">", "gt")
+    meth.gsub!("=", "eq")
+    meth.gsub!("[", "lbracket")
+    meth.gsub!("]", "rbracket")
+    meth.gsub!("^", "carrot")
+    meth.gsub!("|", "line")
+    meth.gsub!("~", "line")
+    meth.gsub!("?", "qmark")
+    meth.gsub!("!", "bang")
+    meth
+  end
+
   # Does nothing at run time
   def self.note_type(x)
     return x
@@ -567,7 +752,7 @@ module RDL
   # Returns a new object that wraps self in a type cast. If force is true this cast is *unchecked*, so use with caution
   def self.type_cast(obj, typ, force: false)
     new_typ = if typ.is_a? RDL::Type::Type then typ else RDL::Globals.parser.scan_str "#T #{typ}" end
-    raise RuntimeError, "type cast error: self not a member of #{new_typ}" unless force || typ.member?(obj)
+    raise RuntimeError, "type cast error: self not a member of #{new_typ}" unless force || new_typ.member?(obj)
     new_obj = SimpleDelegator.new(obj)
     new_obj.instance_variable_set('@__rdl_type', new_typ)
     new_obj
@@ -582,7 +767,7 @@ module RDL
     formals, _, all = RDL::Globals.type_params[klass]
     raise RuntimeError, "Receiver is of class #{klass}, which is not parameterized" unless formals
     raise RuntimeError, "Expecting #{formals.size} type parameters, got #{typs.size}" unless formals.size == typs.size
-    raise RuntimeError, "Instance already has type instantiation" if obj.instance_variable_get(:@__rdl_type)
+    raise RuntimeError, "Instance already has type instantiation" if obj.instance_variable_defined?(:@__rdl_type) && obj.instance_variable_get(:@__rdl_type)
     new_typs = typs.map { |t| if t.is_a? RDL::Type::Type then t else RDL::Globals.parser.scan_str "#T #{t}" end }
     t = RDL::Type::GenericType.new(RDL::Type::NominalType.new(klass), *new_typs)
     if check
@@ -614,9 +799,34 @@ module RDL
     obj.instance_variable_set(:@__rdl_type, nil)
     obj
   end
+
+  private
+  def self.add_ar_assoc(hash, aname, aklass)
+    kl_type = RDL::Type::SingletonType.new(aklass)
+    if hash[aname]
+      hash[aname] = RDL::Type::UnionType.new(hash[aname], kl_type)
+    else
+      hash[aname] = kl_type unless hash[aname]
+    end
+    hash
+  end
+end
+
+class Object
+  def singleton_method_added(meth)
+    klass = self.to_s
+    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+    sklass = RDL::Util.add_singleton_marker(klass)
+    RDL::Wrap.do_method_added(self, true, sklass, meth)
+    nil
+  end  
 end
 
 class Module
+  define_method :singleton_method_added, Object.instance_method(:singleton_method_added)
+
+  RDL::Util.silent_warnings { 
+  
   def method_added(meth)
     klass = self.to_s
     klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
@@ -624,11 +834,45 @@ class Module
     nil
   end
 
-  def singleton_method_added(meth)
-    klass = self.to_s
-    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
-    sklass = RDL::Util.add_singleton_marker(klass)
-    RDL::Wrap.do_method_added(self, true, sklass, meth)
-    nil
+  }
+end
+
+class Class
+  def ===(x)
+    if x.method(:is_a?).owner == SimpleDelegator then super(x.__getobj__) else super(x) end
+  end
+end
+
+class SimpleDelegator
+  ## pass methods through to wrapped object
+  ## necessary when type casts are inside type-level code
+  def is_a?(c)
+    __getobj__.is_a?(c)
+  end
+
+  def instance_of?(c)
+    __getobj__.instance_of?(c)
+  end
+
+  def kind_of?(c)
+    __getobj__.kind_of?(c)
+  end
+
+  def ===(x)
+    __getobj__ === x
   end
+
+  def ==(x)
+    __getobj__ == x
+  end
+
+  def class
+     __getobj__.class
+  end
+
+  def nil?
+     __getobj__.nil?
+  end
+
 end
+