rdl 2.1.0 → 2.2.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (102) hide show
  1. checksums.yaml +5 -5
  2. data/.gitignore +1 -0
  3. data/.travis.yml +7 -6
  4. data/CHANGES.md +29 -0
  5. data/README.md +94 -26
  6. data/lib/rdl/boot.rb +82 -41
  7. data/lib/rdl/boot_rails.rb +5 -0
  8. data/lib/rdl/config.rb +9 -1
  9. data/lib/rdl/query.rb +2 -2
  10. data/lib/rdl/typecheck.rb +972 -225
  11. data/lib/rdl/types/annotated_arg.rb +8 -0
  12. data/lib/rdl/types/ast_node.rb +73 -0
  13. data/lib/rdl/types/bot.rb +8 -0
  14. data/lib/rdl/types/bound_arg.rb +63 -0
  15. data/lib/rdl/types/computed.rb +48 -0
  16. data/lib/rdl/types/dependent_arg.rb +9 -0
  17. data/lib/rdl/types/dynamic.rb +61 -0
  18. data/lib/rdl/types/finite_hash.rb +54 -9
  19. data/lib/rdl/types/generic.rb +33 -0
  20. data/lib/rdl/types/intersection.rb +8 -0
  21. data/lib/rdl/types/lexer.rex +6 -1
  22. data/lib/rdl/types/lexer.rex.rb +13 -1
  23. data/lib/rdl/types/method.rb +14 -0
  24. data/lib/rdl/types/nominal.rb +8 -0
  25. data/lib/rdl/types/non_null.rb +8 -0
  26. data/lib/rdl/types/optional.rb +8 -0
  27. data/lib/rdl/types/parser.racc +31 -5
  28. data/lib/rdl/types/parser.tab.rb +540 -302
  29. data/lib/rdl/types/rdl_types.rb +45 -0
  30. data/lib/rdl/types/singleton.rb +14 -1
  31. data/lib/rdl/types/string.rb +104 -0
  32. data/lib/rdl/types/structural.rb +8 -0
  33. data/lib/rdl/types/top.rb +8 -0
  34. data/lib/rdl/types/tuple.rb +32 -8
  35. data/lib/rdl/types/type.rb +54 -11
  36. data/lib/rdl/types/union.rb +41 -2
  37. data/lib/rdl/types/var.rb +10 -0
  38. data/lib/rdl/types/vararg.rb +8 -0
  39. data/lib/rdl/util.rb +13 -10
  40. data/lib/rdl/wrap.rb +271 -27
  41. data/lib/rdl_disable.rb +16 -2
  42. data/lib/types/active_record.rb +1 -0
  43. data/lib/types/core/array.rb +442 -23
  44. data/lib/types/core/basic_object.rb +3 -3
  45. data/lib/types/core/bigdecimal.rb +5 -0
  46. data/lib/types/core/class.rb +2 -0
  47. data/lib/types/core/dir.rb +3 -3
  48. data/lib/types/core/enumerable.rb +4 -4
  49. data/lib/types/core/enumerator.rb +1 -1
  50. data/lib/types/core/file.rb +4 -4
  51. data/lib/types/core/float.rb +203 -0
  52. data/lib/types/core/hash.rb +390 -15
  53. data/lib/types/core/integer.rb +223 -10
  54. data/lib/types/core/io.rb +2 -2
  55. data/lib/types/core/kernel.rb +8 -5
  56. data/lib/types/core/marshal.rb +3 -0
  57. data/lib/types/core/module.rb +3 -3
  58. data/lib/types/core/numeric.rb +0 -2
  59. data/lib/types/core/object.rb +5 -5
  60. data/lib/types/core/pathname.rb +2 -2
  61. data/lib/types/core/process.rb +1 -3
  62. data/lib/types/core/range.rb +1 -1
  63. data/lib/types/core/regexp.rb +2 -2
  64. data/lib/types/core/set.rb +1 -1
  65. data/lib/types/core/string.rb +408 -16
  66. data/lib/types/core/symbol.rb +3 -3
  67. data/lib/types/core/time.rb +1 -1
  68. data/lib/types/core/uri.rb +13 -13
  69. data/lib/types/rails/_helpers.rb +7 -1
  70. data/lib/types/rails/action_controller/mime_responds.rb +2 -0
  71. data/lib/types/rails/active_record/associations.rb +42 -30
  72. data/lib/types/rails/active_record/comp_types.rb +637 -0
  73. data/lib/types/rails/active_record/finder_methods.rb +1 -1
  74. data/lib/types/rails/active_record/model_schema.rb +28 -16
  75. data/lib/types/rails/active_record/relation.rb +5 -3
  76. data/lib/types/rails/active_record/sql-strings.rb +166 -0
  77. data/lib/types/rails/string.rb +1 -1
  78. data/lib/types/sequel.rb +1 -0
  79. data/lib/types/sequel/comp_types.rb +581 -0
  80. data/rdl.gemspec +5 -4
  81. data/test/test_alias.rb +4 -0
  82. data/test/test_array_types.rb +244 -0
  83. data/test/test_bound_types.rb +80 -0
  84. data/test/test_contract.rb +4 -0
  85. data/test/test_dsl.rb +5 -0
  86. data/test/test_dyn_comptype_checks.rb +206 -0
  87. data/test/test_generic.rb +21 -20
  88. data/test/test_hash_types.rb +322 -0
  89. data/test/test_intersection.rb +1 -0
  90. data/test/test_le.rb +29 -4
  91. data/test/test_member.rb +3 -1
  92. data/test/test_parser.rb +5 -0
  93. data/test/test_query.rb +1 -0
  94. data/test/test_rdl.rb +63 -28
  95. data/test/test_rdl_type.rb +4 -0
  96. data/test/test_string_types.rb +102 -0
  97. data/test/test_type_contract.rb +59 -37
  98. data/test/test_typecheck.rb +480 -75
  99. data/test/test_types.rb +17 -0
  100. data/test/test_wrap.rb +5 -0
  101. metadata +35 -5
  102. data/lib/types/rails/active_record/schema_types.rb +0 -51
@@ -29,6 +29,20 @@ module RDL::Annotate
29
29
  def type_params(*args); end
30
30
  end
31
31
 
32
+ module RDL::RDLAnnotate
33
+ define_method :rdl_pre, RDL::Annotate.instance_method(:pre)
34
+ define_method :rdl_post, RDL::Annotate.instance_method(:post)
35
+ define_method :rdl_type, RDL::Annotate.instance_method(:type)
36
+ define_method :rdl_var_type, RDL::Annotate.instance_method(:var_type)
37
+ define_method :rdl_alias, RDL::Annotate.instance_method(:rdl_alias)
38
+ define_method :rdl_type_params, RDL::Annotate.instance_method(:type_params)
39
+ define_method :rdl_attr_accessor_type, RDL::Annotate.instance_method(:attr_accessor_type) # note in disable these don't call var_type
40
+ define_method :rdl_attr_reader_type, RDL::Annotate.instance_method(:attr_reader_type)
41
+ define_method :rdl_attr_type, RDL::Annotate.instance_method(:attr_type)
42
+ define_method :rdl_attr_writer_type, RDL::Annotate.instance_method(:attr_writer_type)
43
+ end
44
+
45
+
32
46
  module RDL
33
47
  extend RDL::Annotate
34
48
  def self.type_alias(*args); end
@@ -37,8 +51,8 @@ module RDL
37
51
  def self.at(*args); end
38
52
  def self.note_type(*args); end
39
53
  def self.remove_type(*args); end
40
- def self.instantaite!(*args); self; end
41
- def self.deinstantaite!(*args); self; end
54
+ def self.instantiate!(*args); self; end
55
+ def self.deinstantiate!(*args); self; end
42
56
  def self.type_cast(*args); self; end
43
57
  def self.query(*args); end
44
58
  end
@@ -0,0 +1 @@
1
+ Dir[File.dirname(__FILE__) + "/rails/active_record/*.rb"].each { |f| require f }
@@ -2,31 +2,452 @@ RDL.nowrap :Array
2
2
 
3
3
  RDL.type_params :Array, [:t], :all?
4
4
 
5
- RDL.type :Array, :<<, '(t) -> Array<t>'
6
- RDL.type :Array, :[], '(Range<Integer>) -> Array<t>'
7
- RDL.type :Array, :[], '(Integer or Float) -> t'
8
- RDL.type :Array, :[], '(Integer, Integer) -> Array<t>'
5
+ def Array.to_type(t)
6
+ case t
7
+ when RDL::Type::Type
8
+ t
9
+ when Array
10
+ RDL.type_cast(RDL::Type::TupleType.new(*(t.map { |i| to_type(RDL.type_cast(i, "Object")) })), "RDL::Type::TupleType", force: true)
11
+ else
12
+ t = "nil" if t.nil?
13
+ RDL::Globals.parser.scan_str "#T #{t}"
14
+ end
15
+ end
16
+ RDL.type Array, 'self.to_type', "(Object) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
17
+
18
+
19
+ def Array.output_type(trec, targs, meth_name, default1, default2=default1, use_sing_val: true, nil_false_default: false)
20
+ case trec
21
+ when RDL::Type::TupleType
22
+ if targs.empty? || targs.all? { |t| t.is_a?(RDL::Type::SingletonType) }
23
+ vals = RDL.type_cast((if use_sing_val then targs.map { |t| RDL.type_cast(t, "RDL::Type::SingletonType").val } else targs end), "Array<%any>", force: true)
24
+ res = RDL.type_cast(trec.params.send(meth_name, *vals), "Object", force: true)
25
+ if !res && nil_false_default
26
+ if default1 == :promoted_param
27
+ trec.promote.params[0]
28
+ elsif default1 == :promoted_array
29
+ trec.promote
30
+ else
31
+ RDL::Globals.parser.scan_str "#T #{default1}"
32
+ end
33
+ else
34
+ to_type(res)
35
+ end
36
+ else
37
+ if default1 == :promoted_param
38
+ trec.promote.params[0]
39
+ elsif default1 == :promoted_array
40
+ trec.promote
41
+ else
42
+ RDL::Globals.parser.scan_str "#T #{default1}"
43
+ end
44
+ end
45
+ else
46
+ RDL::Globals.parser.scan_str "#T #{default2}"
47
+ end
48
+ end
49
+ RDL.type Array, 'self.output_type', "(RDL::Type::Type, Array<RDL::Type::Type>, Symbol, String or Symbol, ?(String or Symbol), { use_sing_val: ?%bool, nil_false_default: ?%bool }) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
50
+
51
+
52
+ def Array.any_or_t(trec, vararg=false)
53
+ case trec
54
+ when RDL::Type::TupleType
55
+ ret = RDL::Globals.types[:top]
56
+ if vararg then RDL::Type::VarargType.new(ret) else ret end
57
+ else
58
+ ret = RDL::Globals.parser.scan_str "#T t"
59
+ if vararg then RDL::Type::VarargType.new(ret) else ret end
60
+ end
61
+ end
62
+ RDL.type Array, 'self.any_or_t', "(RDL::Type::Type, ?%bool) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
63
+
64
+
65
+ def Array.promoted_or_t(trec, vararg=false)
66
+ case trec
67
+ when RDL::Type::TupleType
68
+ ret = trec.promote.params[0]
69
+ if vararg then RDL::Type::VarargType.new(ret) else ret end
70
+ else
71
+ ret = RDL::Globals.parser.scan_str "#T t"
72
+ if vararg then RDL::Type::VarargType.new(ret) else ret end
73
+ end
74
+ end
75
+ RDL.type Array, 'self.promoted_or_t', "(RDL::Type::Type, ?%bool) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
76
+
77
+
78
+ def Array.promote_tuple(trec)
79
+ case trec
80
+ when RDL::Type::TupleType
81
+ trec.promote
82
+ else
83
+ trec
84
+ end
85
+ end
86
+ RDL.type Array, 'self.promote_tuple', "(RDL::Type::Type) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
87
+
88
+
89
+ def Array.promote_tuple!(trec)
90
+ case trec
91
+ when RDL::Type::TupleType
92
+ raise "Unable to promote tuple." unless trec.promote!
93
+ trec
94
+ else
95
+ trec
96
+ end
97
+ end
98
+ RDL.type Array, 'self.promote_tuple!', "(RDL::Type::Type) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:~, :+]
99
+
100
+ RDL.type :Array, :<<, '(``any_or_t(trec)``) -> ``append_push_output(trec, targs, :<<)``'
101
+
102
+
103
+ def Array.append_push_output(trec, targs, meth)
104
+ case trec
105
+ when RDL::Type::TupleType
106
+ RDL.type_cast(trec.params.send(meth, *RDL.type_cast(targs, "Array<%any>")), "%any", force: true)
107
+ raise RDL::Typecheck::StaticTypeError, "Failed to mutate tuple: new tuple does not match prior type constraints." unless trec.check_bounds(true)
108
+ trec
109
+ else
110
+ RDL::Globals.parser.scan_str "#T Array<t>"
111
+ end
112
+ end
113
+ RDL.type Array, 'self.append_push_output', "(RDL::Type::Type, Array<RDL::Type::Type>, Symbol) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
114
+
115
+ RDL.type :Array, :[], '(Range<Integer>) -> ``output_type(trec, targs, :[], :promoted_array, "Array<t>")``'
116
+ RDL.type :Array, :[], '(Integer or Float) -> ``output_type(trec, targs, :[], :promoted_param, "t")``'
117
+ RDL.type :Array, :[], '(Integer, Integer) -> ``output_type(trec, targs, :[], :promoted_array, "Array<t>")``'
118
+ RDL.type :Array, :&, '(Array<u>) -> ``output_type(trec, targs, :&, :promoted_array, "Array<t>")``'
119
+ RDL.type :Array, :*, '(Integer) -> ``output_type(trec, targs, :*, :promoted_array, "Array<t>")``'
120
+ RDL.type :Array, :*, '(String) -> String'
121
+ RDL.type :Array, :+, '(``plus_input(targs)``) -> ``plus_output(trec, targs)``'
122
+
123
+
124
+ def Array.plus_input(targs)
125
+ case targs[0]
126
+ when RDL::Type::TupleType
127
+ return targs[0]
128
+ when RDL::Type::GenericType
129
+ return RDL::Globals.parser.scan_str "#T Array<u>"
130
+ else
131
+ RDL::Globals.types[:array]
132
+ end
133
+ end
134
+ RDL.type Array, 'self.plus_input', "(Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
135
+
136
+
137
+ def Array.plus_output(trec, targs)
138
+ case trec
139
+ when RDL::Type::NominalType
140
+ return RDL::Globals.types[:array]
141
+ when RDL::Type::GenericType
142
+ case targs[0]
143
+ when RDL::Type::TupleType
144
+ promoted = RDL.type_cast(targs[0], "RDL::Type::TupleType", force: true).promote
145
+ param_union = RDL::Type::UnionType.new(promoted.params[0], trec.params[0])
146
+ return RDL::Type::GenericType.new(trec.base, param_union)
147
+ when RDL::Type::GenericType
148
+ return RDL::Globals.parser.scan_str "#T Array<u or t>"
149
+ else
150
+ ## targs[0] should just be array here
151
+ return RDL::Globals.types[:array]
152
+ end
153
+ when RDL::Type::TupleType
154
+ case targs[0]
155
+ when RDL::Type::TupleType
156
+ return RDL::Type::TupleType.new(*(trec.params + RDL.type_cast(targs[0], "RDL::Type::TupleType", force: true).params))
157
+ when RDL::Type::GenericType
158
+ promoted = trec.promote
159
+ param_union = RDL::Type::UnionType.new(promoted.params[0], RDL.type_cast(targs[0], "RDL::Type::GenericType", force: true).params[0] )
160
+ return RDL::Type::GenericType.new(RDL.type_cast(targs[0], "RDL::Type::GenericType", force: true).base, param_union)
161
+ else
162
+ ## targs[0] should just be Array here
163
+ return RDL::Globals.types[:array]
164
+ end
165
+ end
166
+ end
167
+ RDL.type Array, 'self.plus_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
168
+
169
+ RDL.type :Array, :-, '(Array<u>) -> ``output_type(trec, targs, :-, :promoted_array, "Array<t>")``'
170
+ RDL.type :Array, :slice, '(Range<Integer>) -> ``output_type(trec, targs, :slice, :promoted_array, "Array<t>")``'
171
+ RDL.type :Array, :slice, '(Integer) -> ``output_type(trec, targs, :slice, :promoted_param, "t")``'
172
+ RDL.type :Array, :slice, '(Integer, Integer) -> ``output_type(trec, targs, :slice, :promoted_array, "Array<t>")``'
173
+ RDL.type :Array, :[]=, '(Integer, ``any_or_t(trec)``) -> ``assign_output(trec, targs)``'
174
+
175
+
176
+ def Array.assign_output(trec, targs)
177
+ case trec
178
+ when RDL::Type::TupleType
179
+ case targs[0]
180
+ when RDL::Type::SingletonType
181
+ argval = RDL.type_cast(targs[0], "RDL::Type::SingletonType<Integer>", force: true).val
182
+ if v = trec.params[argval]
183
+ trec.params[argval] = RDL::Type::UnionType.new(v, targs[1])
184
+ trec.params[argval] = Hash.weak_promote(trec.params[argval]) if RDL::Config.instance.weak_update_promote
185
+ raise RDL::Typecheck::StaticTypeError, "Failed to mutate tuple: new tuple does not match previous constraints." unless trec.check_bounds(true)
186
+ targs[1]
187
+ else
188
+ trec.params[RDL.type_cast(targs[0], "RDL::Type::SingletonType<Integer>", force: true).val] = targs[1]
189
+ raise RDL::Typecheck::StaticTypeError, "Failed to mutate tuple: new tuple does not match previous constraints." unless trec.check_bounds(true)
190
+ targs[1]
191
+ end
192
+ else
193
+ raise "Unable to promote tuple." unless trec.promote!(targs[1])
194
+ trec
195
+ end
196
+ else
197
+ RDL::Globals.parser.scan_str "#T t"
198
+ end
199
+ end
200
+ RDL.type Array, 'self.assign_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
201
+
202
+ RDL.type :Array, :[]=, '(Integer, Integer, ``any_or_t(trec)``) -> t'
203
+
204
+
205
+ def Array.multi_assign_output(trec, targs)
206
+ ## this method could get more precise, but it would require many more cases
207
+ return RDL::Globals.types[:top] ### TODO: Figure out better solution. This is here to avoid promote!-ing when type does not actually match.
208
+ =begin
209
+ ## uncomment after figuring out above.
210
+ case trec
211
+ when RDL::Type::TupleType
212
+ element = (if targs.length > 2 then targs[2] else targs[1] end)
213
+ raise "Unable to promote tuple." unless trec.promote!(element)
214
+ element
215
+ else
216
+ RDL::Globals.parser.scan_str "#T t"
217
+ end
218
+ =end
219
+ end
220
+ RDL.type Array, 'self.multi_assign_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
221
+
222
+ RDL.type :Array, :[]=, '(Range<Integer>, ``any_or_t(trec)``) -> ``multi_assign_output(trec, targs)``'
223
+ RDL.type :Array, :assoc, '(t) -> Array<t>'
224
+ RDL.type :Array, :at, '(Integer) -> ``output_type(trec, targs, :at, :promoted_param, "t")``'
225
+ RDL.type :Array, :clear, '() -> self'
226
+ RDL.type :Array, :map, '() {(``promoted_or_t(trec)``) -> u } -> Array<u>'
227
+ RDL.type :Array, :map, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
228
+ RDL.type :Array, :map!, '() {(``promoted_or_t(trec)``) -> u} -> ``map_output(trec)``'
229
+
230
+
231
+ def Array.map_output(trec)
232
+ case trec
233
+ when RDL::Type::TupleType
234
+ trec.params.map! { |e| RDL::Globals.parser.scan_str "#T u" } ## set each element to type u
235
+ raise RDL::Typecheck::StaticTypeError, "Failed to mutate tuple: new tuple does not match previous constraints." unless trec.check_bounds(true)
236
+ trec
237
+ else
238
+ RDL::Globals.parser.scan_str "#T Array<u>"
239
+ end
240
+ end
241
+ RDL.type Array, 'self.map_output', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
242
+
243
+ RDL.type :Array, :map!, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
244
+ RDL.type :Array, :collect, '() {(``promoted_or_t(trec)``) -> u} -> Array<u>'
245
+ RDL.type :Array, :collect, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
246
+ RDL.type :Array, :combination, '(Integer) { (self) -> %any } -> self'
247
+ RDL.type :Array, :combination, '(Integer) -> Enumerator<self>'
248
+ RDL.type :Array, :push, '(``any_or_t(trec, true)``) -> ``append_push_output(trec, targs, :push)``'
249
+ RDL.type ::Array, :compact, '() -> ``RDL::Type::GenericType.new(RDL::Globals.types[:array], promoted_or_t(trec))``'
250
+ RDL.type :Array, :compact!, '() -> ``promote_tuple!(trec)``'
251
+ RDL.type :Array, :concat, '(``promote_tuple(trec)``) -> ``promote_tuple!(trec)``' ## could be more precise here
252
+ RDL.type :Array, :count, '() -> ``output_type(trec, targs, :count, "Integer")``'
253
+ RDL.type :Array, :count, '(``any_or_t(trec)``) -> Integer'
254
+ RDL.type :Array, :count, '() { (``promoted_or_t(trec)``) -> %bool } -> Integer'
255
+ RDL.type :Array, :cycle, '(?Integer) { (``promoted_or_t(trec)``) -> %any } -> %any'
256
+ RDL.type :Array, :cycle, '(?Integer) -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
257
+ RDL.type :Array, :delete, '(u) -> ``promote_tuple!(trec); targs[0]``'
258
+ RDL.type :Array, :delete, '(u) { () -> v } -> ``promote_tuple!(trec); RDL::Globals.parser.scan_str "#T u or v"``'
259
+ RDL.type :Array, :delete_at, '(Integer) -> ``promote_tuple!(trec)``'
260
+ RDL.type :Array, :delete_if, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
261
+ RDL.type :Array, :delete_if, '() -> ``promote_tuple!(trec); RDL::Globals.parser.scan_str "#T Enumerator<t>"``'
262
+ RDL.type :Array, :drop, '(Integer) -> ``promote_tuple!(trec)``'
263
+ RDL.type :Array, :drop_while, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
264
+ RDL.type :Array, :drop_while, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
265
+ RDL.type :Array, :each, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
266
+ RDL.type :Array, :each, '() { (``promoted_or_t(trec)``) -> %any } -> self'
267
+ RDL.type :Array, :each_index, '() { (Integer) -> %any } -> self'
268
+ RDL.type :Array, :each_index, '() -> Enumerator<Integer>'
269
+ RDL.type :Array, :empty?, '() -> ``output_type(trec, targs, :empty?, "%bool")``', effect: [:+, :+]
270
+ RDL.type :Array, :fetch, '(Integer) -> ``output_type(trec, targs, :[], :promoted_param, "t")``'
271
+ RDL.type :Array, :fetch, '(Integer, u) -> ``RDL::Type::UnionType.new(RDL::Globals.parser.scan_str("u"), output_type(trec, targs, :[], :promoted_param, "t"))``'
272
+ RDL.type :Array, :fetch, '(Integer) { (Integer) -> u } -> ``RDL::Type::UnionType.new(RDL::Globals.parser.scan_str("u"), output_type(trec, targs, :[], :promoted_param, "t"))``'
273
+ RDL.type :Array, :fill, '(``any_or_t(trec)``) -> ``fill_output(trec, targs)``'
274
+
275
+
276
+ def Array.fill_output(trec, targs)
277
+ case trec
278
+ when RDL::Type::TupleType
279
+ trec.params.map! { |e|
280
+ if RDL::Config.instance.weak_update_promote
281
+ Hash.weak_promote(RDL::Type::UnionType.new(e, targs[0]).canonical)
282
+ else
283
+ RDL::Type::UnionType.new(e, targs[0]).canonical
284
+ end
285
+ }
286
+ trec.check_bounds(true)
287
+ trec
288
+ else
289
+ RDL::Globals.parser.scan_str "#T Array<t>"
290
+ end
291
+ end
292
+ RDL.type Array, 'self.fill_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
293
+
294
+ RDL.type :Array, :fill, '(``promoted_or_t(trec)``, Integer, ?Integer) -> ``promote_tuple!(trec)``' ## can be more precise for this one, but would require many cases
295
+ RDL.type :Array, :fill, '(``promoted_or_t(trec)``, Range<Integer>) -> ``promote_tuple!(trec)``'
296
+ RDL.type :Array, :fill, '() { (Integer) -> ``promoted_or_t(trec)`` } -> ``promote_tuple!(trec)``'
297
+ RDL.type :Array, :fill, '(Integer, ?Integer) { (Integer) -> ``promoted_or_t(trec)`` } -> ``promote_tuple!(trec)``'
298
+ RDL.type :Array, :fill, '() { (Range<Integer>) -> ``promoted_or_t(trec)`` } -> ``promote_tuple!(trec)``'
299
+ RDL.type :Array, :flatten, '() -> Array<%any>' # Can't give a more precise RDL.type
300
+ RDL.type :Array, :index, '(u) -> ``t = output_type(trec, targs, :index, "Integer", use_sing_val: false, nil_false_default: true)``'
301
+ RDL.type :Array, :index, '() { (``promoted_or_t(trec)``) -> %bool } -> Integer'
302
+ RDL.type :Array, :index, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
303
+ RDL.type :Array, :first, '() -> ``output_type(trec, targs, :first, :promoted_param, "t")``'
304
+ RDL.type :Array, :first, '(Integer) -> ``output_type(trec, targs, :first, :promoted_array, "Array<t>")``'
305
+ RDL.type :Array, :include?, '(%any) -> ``output_type(trec, targs, :include?, "%bool", use_sing_val: false, nil_false_default: true)``'
306
+
307
+
308
+ def Array.include_output(trec, targs)
309
+ case trec
310
+ when RDL::Type::TupleType
311
+ case targs[0]
312
+ when RDL::Type::SingletonType
313
+ if trec.params.include?(targs[0])
314
+ RDL::Globals.types[:true]
315
+ else
316
+ ## in this case, still can't say false because arg may be in tuple, but without singleton type.
317
+ RDL::Globals.types[:bool]
318
+ end
319
+ else
320
+ RDL::Globals.types[:bool]
321
+ end
322
+ else
323
+ RDL::Globals.types[:bool]
324
+ end
325
+ end
326
+ RDL.type Array, 'self.include_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
327
+
328
+
329
+ RDL.type :Array, :insert, '(Integer, ``promoted_or_t(trec)``) -> ``promote_tuple!(trec)``'
330
+ RDL.type :Array, :inspect, '() -> String'
331
+ RDL.type :Array, :join, '(?String) -> String'
332
+ RDL.type :Array, :keep_if, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
333
+ RDL.type :Array, :last, '() -> ``output_type(trec, targs, :last, :promoted_param, "t")``'
334
+ RDL.type :Array, :last, '(Integer) -> ``output_type(trec, targs, :last, :promoted_array, "Array<t>")``'
335
+ RDL.type :Array, :member?, '(u) -> ``output_type(trec, targs, :member?, "%bool", use_sing_val: false, nil_false_default: true)``'
336
+ RDL.type :Array, :length, '() -> ``output_type(trec, targs, :length, "Integer")``'
337
+ RDL.type :Array, :permutation, '(?Integer) -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
338
+ RDL.type :Array, :permuation, '(?Integer) { (``promote_tuple(trec)``) -> %any } -> ``promote_tuple(trec)``'
339
+ RDL.type :Array, :pop, '(Integer) -> ``promote_tuple!(trec)``'
340
+ RDL.type :Array, :pop, '() -> ``promote_tuple(trec); RDL::Globals.parser.scan_str "#T t"``'
341
+ RDL.type :Array, :product, '(*Array<u>) -> ``RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::UnionType.new(promoted_or_t(trec), RDL::Globals.parser.scan_str("#T u"))))``'
342
+ RDL.type :Array, :rassoc, '(u) -> ``promoted_or_t(trec)``'
343
+ RDL.type :Array, :reject, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple(trec)``'
344
+ RDL.type :Array, :reject, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
345
+ RDL.type :Array, :reject!, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
346
+ RDL.type :Array, :reject!, '() -> Enumerator<t>'
347
+ RDL.type :Array, :repeated_combination, '(Integer) { (``promote_tuple(trec)``) -> %any } -> ``promote_tuple(trec)``'
348
+ RDL.type :Array, :repeated_combination, '(Integer) -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
349
+ RDL.type :Array, :repeated_permutation, '(Integer) { (``promote_tuple(trec)``) -> %any } -> ``promote_tuple(trec)``'
350
+ RDL.type :Array, :repeated_permutation, '(Integer) -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
351
+ RDL.type :Array, :reverse, '() -> ``output_type(trec, targs, :reverse, :promoted_array, "Array<t>")``'
352
+ RDL.type :Array, :reverse!, '() -> ``reverse_output(trec)``'
353
+
354
+
355
+ def Array.reverse_output(trec)
356
+ case trec
357
+ when RDL::Type::TupleType
358
+ rev = trec.params.reverse
359
+ i = 0
360
+ trec.params.map! { |e|
361
+ un = RDL::Type::UnionType.new(e, rev[i]).canonical
362
+ i = i + 1
363
+ if RDL::Config.instance.weak_update_promote
364
+ Hash.weak_promote(un)
365
+ else
366
+ un
367
+ end
368
+ }
369
+ trec.check_bounds(true)
370
+ trec
371
+ else
372
+ RDL::Globals.parser.scan_str "#T Array<t>"
373
+ end
374
+ end
375
+ RDL.type Array, 'self.reverse_output', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
376
+
377
+ RDL.type :Array, :reverse_each, '() { (``promoted_or_t(trec)``) -> %any } -> self'
378
+ RDL.type :Array, :reverse_each, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
379
+ RDL.type :Array, :rindex, '(u) -> ``promoted_or_t(trec)``'
380
+ RDL.type :Array, :rindex, '() { (``promoted_or_t(trec)``) -> %bool } -> Integer'
381
+ RDL.type :Array, :rindex, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
382
+ RDL.type :Array, :rotate, '(?Integer) -> ``output_type(trec, targs, :rotate, :promoted_array, "Array<t>")``'
383
+ RDL.type :Array, :rotate!, '(?Integer) -> ``promote_tuple!(trec)``'
384
+ RDL.type :Array, :sample, '() -> ``promoted_or_t(trec)``'
385
+ RDL.type :Array, :sample, '(Integer) -> ``promote_tuple(trec)``'
386
+ RDL.type :Array, :select, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple(trec)``'
387
+ RDL.type :Array, :select, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
388
+ RDL.type :Array, :select!, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
389
+ RDL.type :Array, :select!, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
390
+ RDL.type :Array, :shift, '() -> ``promote_tuple!(trec); RDL::Globals.parser.scan_str "#T t"``'
391
+ RDL.type :Array, :shift, '(Integer) -> ``promote_tuple!(trec)``'
392
+ RDL.type :Array, :shuffle, '() -> ``promote_tuple(trec)``'
393
+ RDL.type :Array, :shuffle!, '() -> ``promote_tuple!(trec)``'
394
+ RDL.rdl_alias :Array, :size, :length
395
+ RDL.rdl_alias :Array, :slice, :[]
396
+ RDL.type :Array, :slice!, '(Range<Integer>) -> ``promote_tuple!(trec)``'
397
+ RDL.type :Array, :slice!, '(Integer, Integer) -> ``promote_tuple!(trec)``'
398
+ RDL.type :Array, :slice!, '(Integer or Float) -> ``promote_tuple!(trec); RDL::Globals.parser.scan_str "#T t"``'
399
+ RDL.type :Array, :sort, '() -> ``promote_tuple(trec)``'
400
+ RDL.type :Array, :sort, '() { (``promoted_or_t(trec)``, ``promoted_or_t(trec)``) -> Integer } -> ``promote_tuple(trec)``'
401
+ RDL.type :Array, :sort!, '() -> ``promote_tuple!(trec)``'
402
+ RDL.type :Array, :sort!, '() { (``promoted_or_t(trec)``,``promoted_or_t(trec)``) -> Integer } -> ``promote_tuple!(trec)``'
403
+ RDL.type :Array, :sort_by!, '() { (``promoted_or_t(trec)``) -> u } -> ``promote_tuple!(trec)``'
404
+ RDL.type :Array, :sort_by!, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
405
+ RDL.type :Array, :take, '(Integer) -> ``output_type(trec, targs, :take, :promoted_array, "Array<t>")``'
406
+ RDL.type :Array, :take_while, '() { (``promoted_or_t(trec)``) ->%bool } -> ``promote_tuple(trec)``'
407
+ RDL.type :Array, :take_while, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
408
+ RDL.type :Array, :to_a, '() -> self'
409
+ RDL.type :Array, :to_ary, '() -> self'
410
+ RDL.rdl_alias :Array, :to_s, :inspect
411
+ RDL.type :Array, :transpose, '() -> ``promote_tuple(trec)``'
412
+ RDL.type :Array, :uniq, '() -> ``promote_tuple(trec)``'
413
+ RDL.type :Array, :uniq!, '() -> ``promote_tuple!(trec)``'
414
+ RDL.type :Array, :unshift, '(``any_or_t(trec, true)``) -> ``promote_tuple!(trec)``'
415
+ RDL.type :Array, :values_at, '(*Integer) -> ``output_type(trec, targs, :values_at, :promoted_array, "Array<t>")``'
416
+ RDL.type :Array, :values_at, '(Range<Integer>) -> ``promote_tuple(trec)``'
417
+ RDL.type :Array, :zip, '(*Array<u>) -> ``RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::UnionType.new(promoted_or_t(trec), RDL::Globals.parser.scan_str("#T u"))))``'
418
+ RDL.type :Array, :|, '(*Array<u>) -> ``RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::UnionType.new(promoted_or_t(trec), RDL::Globals.parser.scan_str("#T u")))``'
419
+
420
+
421
+
422
+
423
+
424
+ ######### Non-dependet types below #########
425
+
426
+ RDL.type :Array, :<<, '(t) -> Array<t>', effect: [:-, :+]
427
+ RDL.type :Array, :[], '(Range<Integer>) -> Array<t>', effect: [:+, :+]
428
+ RDL.type :Array, :[], '(Integer or Float) -> t', effect: [:+, :+]
429
+ RDL.type :Array, :[], '(Integer, Integer) -> Array<t>', effect: [:+, :+]
9
430
  RDL.type :Array, :&, '(Array<u>) -> Array<t>'
10
431
  RDL.type :Array, :*, '(Integer) -> Array<t>'
11
432
  RDL.type :Array, :*, '(String) -> String'
12
- RDL.type :Array, :+, '(Enumerable<u>) -> Array<u or t>'
13
- RDL.type :Array, :+, '(Array<u>) -> Array<u or t>'
433
+ RDL.type :Array, :+, '(Enumerable<u>) -> Array<u or t>', effect: [:+, :+]
434
+ RDL.type :Array, :+, '(Array<u>) -> Array<u or t>', effect: [:+, :+]
14
435
  RDL.type :Array, :-, '(Array<u>) -> Array<u or t>'
15
436
  RDL.type :Array, :slice, '(Range<Integer>) -> Array<t>'
16
437
  RDL.type :Array, :slice, '(Integer) -> t'
17
438
  RDL.type :Array, :slice, '(Integer, Integer) -> Array<t>'
18
- RDL.type :Array, :[]=, '(Integer, t) -> t'
19
- RDL.type :Array, :[]=, '(Integer, Integer, t) -> t'
439
+ RDL.type :Array, :[]=, '(Integer, t) -> t', effect: [:-, :+]
440
+ RDL.type :Array, :[]=, '(Integer, Integer, t) -> t', effect: [:-, :+]
20
441
  # RDL.type :Array, :[]=, '(Integer, Integer, Array<t>) -> Array<t>'
21
442
  # RDL.type :Array, :[]=, '(Range, Array<t>) -> Array<t>'
22
- RDL.type :Array, :[]=, '(Range<Integer>, t) -> t'
443
+ RDL.type :Array, :[]=, '(Range<Integer>, t) -> t', effect: [:-, :+]
23
444
  RDL.type :Array, :assoc, '(t) -> Array<t>'
24
445
  RDL.type :Array, :at, '(Integer) -> t'
25
446
  RDL.type :Array, :clear, '() -> Array<t>'
26
- RDL.type :Array, :map, '() {(t) -> u} -> Array<u>'
27
- RDL.type :Array, :map, '() -> Enumerator<t>'
28
- RDL.type :Array, :map!, '() {(t) -> u} -> Array<u>'
29
- RDL.type :Array, :map!, '() -> Enumerator<t>'
447
+ RDL.type :Array, :map, '() {(t) -> u} -> Array<u>', effect: [:blockdep, :blockdep]
448
+ RDL.type :Array, :map, '() -> Enumerator<t>', effect: [:blockdep, :blockdep]
449
+ RDL.type :Array, :map!, '() {(t) -> u} -> Array<u>', effect: [:-, :blockdep]
450
+ RDL.type :Array, :map!, '() -> Enumerator<t>', effect: [:-, :blockdep]
30
451
  RDL.type :Array, :collect, '() { (t) -> u } -> Array<u>'
31
452
  RDL.type :Array, :collect, '() -> Enumerator<t>'
32
453
  RDL.type :Array, :combination, '(Integer) { (Array<t>) -> %any } -> Array<t>'
@@ -48,8 +469,8 @@ RDL.type :Array, :delete_if, '() -> Enumerator<t>'
48
469
  RDL.type :Array, :drop, '(Integer) -> Array<t>'
49
470
  RDL.type :Array, :drop_while, '() { (t) -> %bool } -> Array<t>'
50
471
  RDL.type :Array, :drop_while, '() -> Enumerator<t>'
51
- RDL.type :Array, :each, '() -> Enumerator<t>'
52
- RDL.type :Array, :each, '() { (t) -> %any } -> Array<t>'
472
+ RDL.type :Array, :each, '() -> Enumerator<t>', effect: [:-, :blockdep]
473
+ RDL.type :Array, :each, '() { (t) -> %any } -> Array<t>', effect: [:-, :blockdep]
53
474
  RDL.type :Array, :each_index, '() { (Integer) -> %any } -> Array<t>'
54
475
  RDL.type :Array, :each_index, '() -> Enumerator<t>'
55
476
  RDL.type :Array, :empty?, '() -> %bool'
@@ -68,25 +489,26 @@ RDL.type :Array, :index, '() { (t) -> %bool } -> Integer'
68
489
  RDL.type :Array, :index, '() -> Enumerator<t>'
69
490
  RDL.type :Array, :first, '() -> t'
70
491
  RDL.type :Array, :first, '(Integer) -> Array<t>'
71
- RDL.type :Array, :include?, '(u) -> %bool'
492
+ RDL.type :Array, :include?, '(u) -> %bool', effect: [:+, :+]
72
493
  RDL.type :Array, :initialize, '() -> self'
73
494
  RDL.type :Array, :initialize, '(Integer) -> self'
74
495
  RDL.type :Array, :initialize, '(Integer, t) -> self<t>'
496
+ RDL.type :Array, :initialize, '(Array<k>) -> self<k>'
75
497
  RDL.type :Array, :insert, '(Integer, *t) -> Array<t>'
76
498
  RDL.type :Array, :inspect, '() -> String'
77
499
  RDL.type :Array, :join, '(?String) -> String'
78
500
  RDL.type :Array, :keep_if, '() { (t) -> %bool } -> Array<t>'
79
501
  RDL.type :Array, :last, '() -> t'
80
502
  RDL.type :Array, :last, '(Integer) -> Array<t>'
81
- RDL.type :Array, :member, '(u) -> %bool'
82
- RDL.type :Array, :length, '() -> Integer'
503
+ RDL.type :Array, :member?, '(u) -> %bool', effect: [:+, :+]
504
+ RDL.type :Array, :length, '() -> Integer', effect: [:+, :+]
83
505
  RDL.type :Array, :permutation, '(?Integer) -> Enumerator<t>'
84
506
  RDL.type :Array, :permutation, '(?Integer) { (Array<t>) -> %any } -> Array<t>'
85
507
  RDL.type :Array, :pop, '(Integer) -> Array<t>'
86
508
  RDL.type :Array, :pop, '() -> t'
87
509
  RDL.type :Array, :product, '(*Array<u>) -> Array<Array<t or u>>'
88
510
  RDL.type :Array, :rassoc, '(u) -> t'
89
- RDL.type :Array, :reject, '() { (t) -> %bool } -> Array<t>'
511
+ RDL.type :Array, :reject, '() { (t) -> %bool } -> Array<t>', effect: [:+, :blockdep]
90
512
  RDL.type :Array, :reject, '() -> Enumerator<t>'
91
513
  RDL.type :Array, :reject!, '() { (t) -> %bool } -> Array<t>'
92
514
  RDL.type :Array, :reject!, '() -> Enumerator<t>'
@@ -94,7 +516,7 @@ RDL.type :Array, :repeated_combination, '(Integer) { (Array<t>) -> %any } -> Arr
94
516
  RDL.type :Array, :repeated_combination, '(Integer) -> Enumerator<t>'
95
517
  RDL.type :Array, :repeated_permutation, '(Integer) { (Array<t>) -> %any } -> Array<t>'
96
518
  RDL.type :Array, :repeated_permutation, '(Integer) -> Enumerator<t>'
97
- RDL.type :Array, :reverse, '() -> Array<t>'
519
+ RDL.type :Array, :reverse, '() -> Array<t>', effect: [:+, :+]
98
520
  RDL.type :Array, :reverse!, '() -> Array<t>'
99
521
  RDL.type :Array, :reverse_each, '() { (t) -> %any } -> Array<t>'
100
522
  RDL.type :Array, :reverse_each, '() -> Enumerator<t>'
@@ -113,8 +535,6 @@ RDL.type :Array, :shift, '() -> t'
113
535
  RDL.type :Array, :shift, '(Integer) -> Array<t>'
114
536
  RDL.type :Array, :shuffle, '() -> Array<t>'
115
537
  RDL.type :Array, :shuffle!, '() -> Array<t>'
116
- RDL.rdl_alias :Array, :size, :length
117
- RDL.rdl_alias :Array, :slice, :[]
118
538
  RDL.type :Array, :slice!, '(Range<Integer>) -> Array<t>'
119
539
  RDL.type :Array, :slice!, '(Integer, Integer) -> Array<t>'
120
540
  RDL.type :Array, :slice!, '(Integer or Float) -> t'
@@ -129,7 +549,6 @@ RDL.type :Array, :take_while, '() { (t) ->%bool } -> Array<t>'
129
549
  RDL.type :Array, :take_while, '() -> Enumerator<t>'
130
550
  RDL.type :Array, :to_a, '() -> Array<t>'
131
551
  RDL.type :Array, :to_ary, '() -> Array<t>'
132
- RDL.rdl_alias :Array, :to_s, :inspect
133
552
  RDL.type :Array, :transpose, '() -> Array<t>'
134
553
  RDL.type :Array, :uniq, '() -> Array<t>'
135
554
  RDL.type :Array, :uniq!, '() -> Array<t>'