OLD | NEW |
1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/resolver.h" | 5 #include "vm/resolver.h" |
6 | 6 |
7 #include "vm/dart_entry.h" | 7 #include "vm/dart_entry.h" |
8 #include "vm/flags.h" | 8 #include "vm/flags.h" |
9 #include "vm/isolate.h" | 9 #include "vm/isolate.h" |
10 #include "vm/log.h" | 10 #include "vm/log.h" |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
139 } | 139 } |
140 cls = cls.SuperClass(); | 140 cls = cls.SuperClass(); |
141 } | 141 } |
142 return function.raw(); | 142 return function.raw(); |
143 } | 143 } |
144 | 144 |
145 | 145 |
146 RawFunction* Resolver::ResolveStatic(const Library& library, | 146 RawFunction* Resolver::ResolveStatic(const Library& library, |
147 const String& class_name, | 147 const String& class_name, |
148 const String& function_name, | 148 const String& function_name, |
| 149 intptr_t type_args_len, |
149 intptr_t num_arguments, | 150 intptr_t num_arguments, |
150 const Array& argument_names) { | 151 const Array& argument_names) { |
151 ASSERT(!library.IsNull()); | 152 ASSERT(!library.IsNull()); |
152 Function& function = Function::Handle(); | 153 Function& function = Function::Handle(); |
153 if (class_name.IsNull() || (class_name.Length() == 0)) { | 154 if (class_name.IsNull() || (class_name.Length() == 0)) { |
154 // Check if we are referring to a top level function. | 155 // Check if we are referring to a top level function. |
155 const Object& object = Object::Handle(library.ResolveName(function_name)); | 156 const Object& object = Object::Handle(library.ResolveName(function_name)); |
156 if (!object.IsNull() && object.IsFunction()) { | 157 if (!object.IsNull() && object.IsFunction()) { |
157 function ^= object.raw(); | 158 function ^= object.raw(); |
158 if (!function.AreValidArguments(num_arguments, argument_names, NULL)) { | 159 if (!function.AreValidArguments(type_args_len, num_arguments, |
| 160 argument_names, NULL)) { |
159 if (FLAG_trace_resolving) { | 161 if (FLAG_trace_resolving) { |
160 String& error_message = String::Handle(); | 162 String& error_message = String::Handle(); |
161 // Obtain more detailed error message. | 163 // Obtain more detailed error message. |
162 function.AreValidArguments(num_arguments, argument_names, | 164 function.AreValidArguments(type_args_len, num_arguments, |
163 &error_message); | 165 argument_names, &error_message); |
164 THR_Print("ResolveStatic error '%s': %s.\n", | 166 THR_Print("ResolveStatic error '%s': %s.\n", |
165 function_name.ToCString(), error_message.ToCString()); | 167 function_name.ToCString(), error_message.ToCString()); |
166 } | 168 } |
167 function = Function::null(); | 169 function = Function::null(); |
168 } | 170 } |
169 } else { | 171 } else { |
170 if (FLAG_trace_resolving) { | 172 if (FLAG_trace_resolving) { |
171 THR_Print("ResolveStatic error: function '%s' not found.\n", | 173 THR_Print("ResolveStatic error: function '%s' not found.\n", |
172 function_name.ToCString()); | 174 function_name.ToCString()); |
173 } | 175 } |
174 } | 176 } |
175 } else { | 177 } else { |
176 // Lookup class_name in the library's class dictionary to get at | 178 // Lookup class_name in the library's class dictionary to get at |
177 // the dart class object. If class_name is not found in the dictionary | 179 // the dart class object. If class_name is not found in the dictionary |
178 // ResolveStatic will return a NULL function object. | 180 // ResolveStatic will return a NULL function object. |
179 const Class& cls = Class::Handle(library.LookupClass(class_name)); | 181 const Class& cls = Class::Handle(library.LookupClass(class_name)); |
180 if (!cls.IsNull()) { | 182 if (!cls.IsNull()) { |
181 function = | 183 function = ResolveStatic(cls, function_name, type_args_len, num_arguments, |
182 ResolveStatic(cls, function_name, num_arguments, argument_names); | 184 argument_names); |
183 } | 185 } |
184 if (FLAG_trace_resolving && function.IsNull()) { | 186 if (FLAG_trace_resolving && function.IsNull()) { |
185 THR_Print("ResolveStatic error: function '%s.%s' not found.\n", | 187 THR_Print("ResolveStatic error: function '%s.%s' not found.\n", |
186 class_name.ToCString(), function_name.ToCString()); | 188 class_name.ToCString(), function_name.ToCString()); |
187 } | 189 } |
188 } | 190 } |
189 return function.raw(); | 191 return function.raw(); |
190 } | 192 } |
191 | 193 |
192 | 194 |
193 RawFunction* Resolver::ResolveStatic(const Class& cls, | 195 RawFunction* Resolver::ResolveStatic(const Class& cls, |
194 const String& function_name, | 196 const String& function_name, |
| 197 intptr_t type_args_len, |
195 intptr_t num_arguments, | 198 intptr_t num_arguments, |
196 const Array& argument_names) { | 199 const Array& argument_names) { |
197 ASSERT(!cls.IsNull()); | 200 ASSERT(!cls.IsNull()); |
198 if (FLAG_trace_resolving) { | 201 if (FLAG_trace_resolving) { |
199 THR_Print("ResolveStatic '%s'\n", function_name.ToCString()); | 202 THR_Print("ResolveStatic '%s'\n", function_name.ToCString()); |
200 } | 203 } |
201 const Function& function = | 204 const Function& function = |
202 Function::Handle(cls.LookupStaticFunction(function_name)); | 205 Function::Handle(cls.LookupStaticFunction(function_name)); |
203 if (function.IsNull() || | 206 if (function.IsNull() || |
204 !function.AreValidArguments(num_arguments, argument_names, NULL)) { | 207 !function.AreValidArguments(type_args_len, num_arguments, argument_names, |
| 208 NULL)) { |
205 // Return a null function to signal to the upper levels to throw a | 209 // Return a null function to signal to the upper levels to throw a |
206 // resolution error or maybe throw the error right here. | 210 // resolution error or maybe throw the error right here. |
207 if (FLAG_trace_resolving) { | 211 if (FLAG_trace_resolving) { |
208 String& error_message = String::Handle(String::New("function not found")); | 212 String& error_message = String::Handle(String::New("function not found")); |
209 if (!function.IsNull()) { | 213 if (!function.IsNull()) { |
210 // Obtain more detailed error message. | 214 // Obtain more detailed error message. |
211 function.AreValidArguments(num_arguments, argument_names, | 215 function.AreValidArguments(type_args_len, num_arguments, argument_names, |
212 &error_message); | 216 &error_message); |
213 } | 217 } |
214 THR_Print("ResolveStatic error '%s': %s.\n", function_name.ToCString(), | 218 THR_Print("ResolveStatic error '%s': %s.\n", function_name.ToCString(), |
215 error_message.ToCString()); | 219 error_message.ToCString()); |
216 } | 220 } |
217 return Function::null(); | 221 return Function::null(); |
218 } | 222 } |
219 return function.raw(); | 223 return function.raw(); |
220 } | 224 } |
221 | 225 |
222 | 226 |
223 RawFunction* Resolver::ResolveStaticAllowPrivate(const Class& cls, | 227 RawFunction* Resolver::ResolveStaticAllowPrivate(const Class& cls, |
224 const String& function_name, | 228 const String& function_name, |
| 229 intptr_t type_args_len, |
225 intptr_t num_arguments, | 230 intptr_t num_arguments, |
226 const Array& argument_names) { | 231 const Array& argument_names) { |
227 ASSERT(!cls.IsNull()); | 232 ASSERT(!cls.IsNull()); |
228 if (FLAG_trace_resolving) { | 233 if (FLAG_trace_resolving) { |
229 THR_Print("ResolveStaticAllowPrivate '%s'\n", function_name.ToCString()); | 234 THR_Print("ResolveStaticAllowPrivate '%s'\n", function_name.ToCString()); |
230 } | 235 } |
231 const Function& function = | 236 const Function& function = |
232 Function::Handle(cls.LookupStaticFunctionAllowPrivate(function_name)); | 237 Function::Handle(cls.LookupStaticFunctionAllowPrivate(function_name)); |
233 if (function.IsNull() || | 238 if (function.IsNull() || |
234 !function.AreValidArguments(num_arguments, argument_names, NULL)) { | 239 !function.AreValidArguments(type_args_len, num_arguments, argument_names, |
| 240 NULL)) { |
235 // Return a null function to signal to the upper levels to throw a | 241 // Return a null function to signal to the upper levels to throw a |
236 // resolution error or maybe throw the error right here. | 242 // resolution error or maybe throw the error right here. |
237 if (FLAG_trace_resolving) { | 243 if (FLAG_trace_resolving) { |
238 String& error_message = String::Handle(String::New("function not found")); | 244 String& error_message = String::Handle(String::New("function not found")); |
239 if (!function.IsNull()) { | 245 if (!function.IsNull()) { |
240 // Obtain more detailed error message. | 246 // Obtain more detailed error message. |
241 function.AreValidArguments(num_arguments, argument_names, | 247 function.AreValidArguments(type_args_len, num_arguments, argument_names, |
242 &error_message); | 248 &error_message); |
243 } | 249 } |
244 THR_Print("ResolveStaticAllowPrivate error '%s': %s.\n", | 250 THR_Print("ResolveStaticAllowPrivate error '%s': %s.\n", |
245 function_name.ToCString(), error_message.ToCString()); | 251 function_name.ToCString(), error_message.ToCString()); |
246 } | 252 } |
247 return Function::null(); | 253 return Function::null(); |
248 } | 254 } |
249 return function.raw(); | 255 return function.raw(); |
250 } | 256 } |
251 | 257 |
252 } // namespace dart | 258 } // namespace dart |
OLD | NEW |