?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
BOO-999
[boo.git] / src / Boo.Lang.Compiler / Steps / ProcessMethodBodies.cs
blob1f9b46dd661b66a5f4981c84df960c1eacb915c9
1 #region license
2 // Copyright (c) 2004, Rodrigo B. de Oliveira (rbo@acm.org)
3 // All rights reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without modification,
6 // are permitted provided that the following conditions are met:
7 //
8 // * Redistributions of source code must retain the above copyright notice,
9 // this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright notice,
11 // this list of conditions and the following disclaimer in the documentation
12 // and/or other materials provided with the distribution.
13 // * Neither the name of Rodrigo B. de Oliveira nor the names of its
14 // contributors may be used to endorse or promote products derived from this
15 // software without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
18 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
21 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
23 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
24 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #endregion
28
29 using System;
30 using System.Collections;
31 using System.Diagnostics;
32 using System.IO;
33 using System.Reflection;
34 using System.Text;
35 using Boo.Lang.Compiler.Ast;
36 using Boo.Lang.Compiler.Ast.Visitors;
37 using Boo.Lang.Compiler.TypeSystem;
38 using Boo.Lang.Runtime;
39 using Attribute = Boo.Lang.Compiler.Ast.Attribute;
40 using Module=Boo.Lang.Compiler.Ast.Module;
41
42 namespace Boo.Lang.Compiler.Steps
43 {
44 /// <summary>
45 /// AST semantic evaluation.
46 /// </summary>
47 public class ProcessMethodBodies : AbstractNamespaceSensitiveVisitorCompilerStep
48 {
49 static readonly ExpressionCollection EmptyExpressionCollection = new ExpressionCollection();
50
51 static readonly object OptionalReturnStatementAnnotation = new object();
52
53 protected Stack _methodStack;
54
55 protected Stack _memberStack;
56 // for accurate error reporting during type inference
57
58 protected Module _currentModule;
59
60 protected InternalMethod _currentMethod;
61
62 IMethod Array_EnumerableConstructor;
63
64 IMethod Array_TypedEnumerableConstructor;
65
66 IMethod Array_TypedCollectionConstructor;
67
68 IMethod Array_TypedConstructor2;
69
70 IMethod MultiDimensionalArray_TypedConstructor;
71
72 protected CallableResolutionService _callableResolution;
73
74 protected bool _optimizeNullComparisons = true;
75
76 public ProcessMethodBodies()
77 {
78 }
79
80 override public void Run()
81 {
82 NameResolutionService.Reset();
83
84 _currentModule = null;
85 _currentMethod = null;
86 _methodStack = new Stack();
87 _memberStack = new Stack();
88
89 _callableResolution = new CallableResolutionService();
90 _callableResolution.Initialize(_context);
91
92 InitializeMemberCache();
93
94 Visit(CompileUnit);
95 }
96
97 protected IMethod ResolveMethod(IType type, string name)
98 {
99 return NameResolutionService.ResolveMethod(type, name);
100 }
101
102 protected IProperty ResolveProperty(IType type, string name)
103 {
104 return NameResolutionService.ResolveProperty(type, name);
105 }
106
107 virtual protected void InitializeMemberCache()
108 {
109 Array_EnumerableConstructor = TypeSystemServices.Map(Types.Builtins.GetMethod("array", new Type[] { Types.IEnumerable }));
110 Array_TypedEnumerableConstructor = TypeSystemServices.Map(Types.Builtins.GetMethod("array", new Type[] { Types.Type, Types.IEnumerable }));
111 Array_TypedCollectionConstructor= TypeSystemServices.Map(Types.Builtins.GetMethod("array", new Type[] { Types.Type, Types.ICollection }));
112 Array_TypedConstructor2 = TypeSystemServices.Map(Types.Builtins.GetMethod("array", new Type[] { Types.Type, Types.Int }));
113 MultiDimensionalArray_TypedConstructor = TypeSystemServices.Map(Types.Builtins.GetMethod("matrix", new Type[] { Types.Type, typeof(int[]) }));
114 }
115
116 override public void Dispose()
117 {
118 base.Dispose();
119
120 if (null != _callableResolution)
121 {
122 _callableResolution.Dispose();
123 _callableResolution = null;
124 }
125
126 _currentModule = null;
127 _currentMethod = null;
128 _methodStack = null;
129 _memberStack = null;
130
131 _RuntimeServices_Len = null;
132 _RuntimeServices_Mid = null;
133 _RuntimeServices_NormalizeStringIndex = null;
134 _RuntimeServices_AddArrays = null;
135 _RuntimeServices_GetRange1 = null;
136 _RuntimeServices_GetRange2 = null;
137 _RuntimeServices_GetMultiDimensionalRange1 = null;
138 _RuntimeServices_SetMultiDimensionalRange1 = null;
139 _RuntimeServices_GetEnumerable = null;
140 _RuntimeServices_EqualityOperator = null;
141 _Array_get_Length = null;
142 _Array_GetLength = null;
143 _String_get_Length = null;
144 _String_Substring_Int = null;
145 _ICollection_get_Count = null;
146 _List_GetRange1 = null;
147 _List_GetRange2 = null;
148 _ICallable_Call = null;
149 _Activator_CreateInstance = null;
150 _Exception_StringConstructor = null;
151 _TextReaderEnumerator_lines = null;
152 }
153
154 override public void OnModule(Module module)
155 {
156 if (WasVisited(module)) return;
157 MarkVisited(module);
158 _currentModule = module;
159
160 EnterNamespace((INamespace)TypeSystemServices.GetEntity(module));
161
162 Visit(module.Members);
163 Visit(module.AssemblyAttributes);
164
165 LeaveNamespace();
166 }
167
168 override public void OnInterfaceDefinition(InterfaceDefinition node)
169 {
170 if (WasVisited(node)) return;
171 MarkVisited(node);
172
173 VisitTypeDefinition(node);
174 }
175
176 private void VisitBaseTypes(TypeDefinition node)
177 {
178 foreach (TypeReference typeRef in node.BaseTypes)
179 {
180 EnsureRelatedNodeWasVisited(typeRef, typeRef.Entity);
181 }
182 }
183
184 private void VisitTypeDefinition(TypeDefinition node)
185 {
186 INamespace ns = (INamespace)GetEntity(node);
187 EnterNamespace(ns);
188 VisitBaseTypes(node);
189 Visit(node.Attributes);
190 Visit(node.Members);
191 LeaveNamespace();
192 }
193
194 override public void OnClassDefinition(ClassDefinition node)
195 {
196 if (WasVisited(node)) return;
197 MarkVisited(node);
198
199 VisitTypeDefinition(node);
200 ProcessFieldInitializers(node);
201 }
202
203 void ProcessFieldInitializers(ClassDefinition node)
204 {
205 foreach (TypeMember member in node.Members)
206 {
207 if (NodeType.Field == member.NodeType)
208 {
209 ProcessFieldInitializer((Field) member);
210 }
211 }
212 }
213
214 override public void OnAttribute(Attribute node)
215 {
216 IType tag = node.Entity as IType;
217 if (null != tag && !TypeSystemServices.IsError(tag))
218 {
219 Visit(node.Arguments);
220 ResolveNamedArguments(tag, node.NamedArguments);
221
222 IConstructor constructor = GetCorrectConstructor(node, tag, node.Arguments);
223 if (null != constructor)
224 {
225 Bind(node, constructor);
226 }
227 }
228 }
229
230 override public void OnProperty(Property node)
231 {
232 if (WasVisited(node))
233 {
234 return;
235 }
236 MarkVisited(node);
237
238 Method setter = node.Setter;
239 Method getter = node.Getter;
240
241 Visit(node.Attributes);
242 Visit(node.Type);
243 Visit(node.Parameters);
244
245 ResolvePropertyOverride(node);
246
247 if (null != getter)
248 {
249 if (null != node.Type)
250 {
251 getter.ReturnType = node.Type.CloneNode();
252 }
253 getter.Parameters.ExtendWithClones(node.Parameters);
254
255 Visit(getter);
256 }
257
258 IType typeInfo = null;
259 if (null != node.Type)
260 {
261 typeInfo = GetType(node.Type);
262 }
263 else
264 {
265 if (null != getter)
266 {
267 typeInfo = GetType(node.Getter.ReturnType);
268 if (typeInfo == TypeSystemServices.VoidType)
269 {
270 typeInfo = TypeSystemServices.ObjectType;
271 node.Getter.ReturnType = CodeBuilder.CreateTypeReference(getter.LexicalInfo, typeInfo);
272 }
273 }
274 else
275 {
276 typeInfo = TypeSystemServices.ObjectType;
277 }
278 node.Type = CodeBuilder.CreateTypeReference(node.LexicalInfo, typeInfo);
279 }
280
281 if (null != setter)
282 {
283 ParameterDeclaration parameter = new ParameterDeclaration();
284 parameter.Type = CodeBuilder.CreateTypeReference(typeInfo);
285 parameter.Name = "value";
286 parameter.Entity = new InternalParameter(parameter, node.Parameters.Count+CodeBuilder.GetFirstParameterIndex(setter));
287 setter.Parameters.ExtendWithClones(node.Parameters);
288 setter.Parameters.Add(parameter);
289 setter.Name = "set_" + node.Name;
290 Visit(setter);
291 }
292 }
293
294 override public void OnField(Field node)
295 {
296 if (WasVisited(node)) return;
297 MarkVisited(node);
298
299 InternalField entity = (InternalField)GetEntity(node);
300
301 Visit(node.Attributes);
302 Visit(node.Type);
303
304 if (null != node.Initializer)
305 {
306 IType type = (null != node.Type) ? GetType(node.Type) : null;
307 if (null != type && TypeSystemServices.IsNullable(type))
308 {
309 BindNullableInitializer(node, node.Initializer, type);
310 }
311 if (entity.DeclaringType.IsValueType && !node.IsStatic)
312 {
313 Error(
314 CompilerErrorFactory.ValueTypeFieldsCannotHaveInitializers(
315 node.Initializer));
316 }
317 try
318 {
319 PushMember(node);
320 PreProcessFieldInitializer(node);
321 }
322 finally
323 {
324 PopMember();
325 }
326 }
327 else
328 {
329 if (null == node.Type)
330 {
331 node.Type = CreateTypeReference(node.LexicalInfo, TypeSystemServices.ObjectType);
332 }
333 }
334 CheckFieldType(node.Type);
335 }
336
337 bool IsValidLiteralInitializer(Expression e)
338 {
339 switch (e.NodeType)
340 {
341 case NodeType.BoolLiteralExpression:
342 case NodeType.IntegerLiteralExpression:
343 case NodeType.DoubleLiteralExpression:
344 case NodeType.NullLiteralExpression:
345 case NodeType.StringLiteralExpression:
346 {
347 return true;
348 }
349 }
350 return false;
351 }
352
353 void ProcessLiteralField(Field node)
354 {
355 Visit(node.Initializer);
356 ProcessFieldInitializerType(node, node.Initializer.ExpressionType);
357 ((InternalField)node.Entity).StaticValue = node.Initializer;
358 node.Initializer = null;
359 }
360
361 void ProcessFieldInitializerType(Field node, IType initializerType)
362 {
363 if (null == node.Type)
364 {
365 node.Type = CreateTypeReference(node.LexicalInfo, MapNullToObject(initializerType));
366 }
367 else
368 {
369 AssertTypeCompatibility(node.Initializer, GetType(node.Type), initializerType);
370 }
371 }
372
373 private TypeReference CreateTypeReference(LexicalInfo info, IType type)
374 {
375 TypeReference reference = CodeBuilder.CreateTypeReference(type);
376 reference.LexicalInfo = info;
377 return reference;
378 }
379
380 private void PreProcessFieldInitializer(Field node)
381 {
382 Expression initializer = node.Initializer;
383 if (node.IsFinal && node.IsStatic)
384 {
385 if (IsValidLiteralInitializer(initializer))
386 {
387 ProcessLiteralField(node);
388 return;
389 }
390 }
391
392 Method method = GetFieldsInitializerMethod(node);
393 InternalMethod entity = (InternalMethod)method.Entity;
394
395 ReferenceExpression temp = new ReferenceExpression("___temp_initializer");
396 BinaryExpression assignment = new BinaryExpression(
397 node.LexicalInfo,
398 BinaryOperatorType.Assign,
399 temp,
400 initializer);
401
402 ProcessNodeInMethodContext(entity, entity, assignment);
403 method.Locals.RemoveByEntity(temp.Entity);
404
405 IType initializerType = GetExpressionType(assignment.Right);
406 ProcessFieldInitializerType(node, initializerType);
407 node.Initializer = assignment.Right;
408 }
409
410 void ProcessFieldInitializer(Field node)
411 {
412 Expression initializer = node.Initializer;
413 if (null == initializer) return;
414
415 Method method = GetFieldsInitializerMethod(node);
416 method.Body.Add(
417 CodeBuilder.CreateAssignment(
418 initializer.LexicalInfo,
419 CodeBuilder.CreateReference(node),
420 initializer));
421 node.Initializer = null;
422 }
423
424 Method CreateInitializerMethod(TypeDefinition type, string name, TypeMemberModifiers modifiers)
425 {
426 Method method = new Method(name);
427 method.Modifiers |= modifiers;
428 method.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType);
429
430 InternalMethod entity = new InternalMethod(TypeSystemServices, method);
431 method.Entity = entity;
432 type.Members.Add(method);
433 MarkVisited(method);
434 return method;
435 }
436
437 Method GetFieldsInitializerMethod(Field node)
438 {
439 TypeDefinition type = node.DeclaringType;
440 string methodName = node.IsStatic ? "$static_initializer$" : "$initializer$";
441 Method method = (Method)type[methodName];
442 if (null == method)
443 {
444 if (node.IsStatic)
445 {
446 if (null == FindStaticConstructor(type))
447 {
448 // when the class doesnt have a static constructor
449 // yet, create one and use it as the static
450 // field initializer method
451 method = CreateStaticConstructor(type);
452 }
453 else
454 {
455 method = CreateInitializerMethod(type, methodName, TypeMemberModifiers.Static);
456 AddInitializerToStaticConstructor(type, (InternalMethod)method.Entity);
457 }
458 }
459 else
460 {
461 method = CreateInitializerMethod(type, methodName, TypeMemberModifiers.None);
462 AddInitializerToInstanceConstructors(type, (InternalMethod)method.Entity);
463 }
464
465 type[methodName] = method;
466 }
467 return method;
468 }
469
470 void AddInitializerToStaticConstructor(TypeDefinition type, InternalMethod initializer)
471 {
472 GetStaticConstructor(type).Body.Insert(0,
473 CodeBuilder.CreateMethodInvocation(initializer));
474 }
475
476 void AddInitializerToInstanceConstructors(TypeDefinition type, InternalMethod initializer)
477 {
478 foreach (TypeMember node in type.Members)
479 {
480 if (NodeType.Constructor == node.NodeType && !node.IsStatic)
481 {
482 Constructor constructor = (Constructor)node;
483 constructor.Body.Insert(GetIndexAfterSuperInvocation(constructor.Body),
484 CodeBuilder.CreateMethodInvocation(
485 CodeBuilder.CreateSelfReference((IType)type.Entity),
486 initializer));
487 }
488 }
489 }
490
491 int GetIndexAfterSuperInvocation(Block body)
492 {
493 int index = 0;
494 foreach (Statement s in body.Statements)
495 {
496 if (NodeType.ExpressionStatement == s.NodeType)
497 {
498 Expression expression = ((ExpressionStatement)s).Expression;
499 if (NodeType.MethodInvocationExpression == expression.NodeType)
500 {
501 if (NodeType.SuperLiteralExpression == ((MethodInvocationExpression)expression).Target.NodeType)
502 {
503 return index + 1;
504 }
505 }
506 }
507 ++index;
508 }
509 return 0;
510 }
511
512 Constructor FindStaticConstructor(TypeDefinition type)
513 {
514 foreach (TypeMember member in type.Members)
515 {
516 if (member.IsStatic && NodeType.Constructor == member.NodeType)
517 {
518 return (Constructor)member;
519 }
520 }
521 return null;
522 }
523
524 Constructor GetStaticConstructor(TypeDefinition type)
525 {
526 Constructor constructor = FindStaticConstructor(type);
527 if (null == constructor)
528 {
529 constructor = CreateStaticConstructor(type);
530 }
531 return constructor;
532 }
533
534 Constructor CreateStaticConstructor(TypeDefinition type)
535 {
536 Constructor constructor = new Constructor();
537 constructor.Entity = new InternalConstructor(TypeSystemServices, constructor);
538 constructor.Modifiers = TypeMemberModifiers.Public|TypeMemberModifiers.Static;
539 type.Members.Add(constructor);
540 MarkVisited(constructor);
541 return constructor;
542 }
543
544 void AddFieldInitializerToStaticConstructor(int index, Field node)
545 {
546 Constructor constructor = GetStaticConstructor(node.DeclaringType);
547 Statement stmt = CodeBuilder.CreateFieldAssignment(node, node.Initializer);
548 constructor.Body.Statements.Insert(index, stmt);
549 node.Initializer = null;
550 }
551
552 void CheckRuntimeMethod(Method method)
553 {
554 if (method.Body.Statements.Count > 0)
555 {
556 Error(CompilerErrorFactory.RuntimeMethodBodyMustBeEmpty(method, method.FullName));
557 }
558 }
559
560 override public void OnConstructor(Constructor node)
561 {
562 if (WasVisited(node))
563 {
564 return;
565 }
566 MarkVisited(node);
567
568 Visit(node.Attributes);
569 Visit(node.Parameters);
570
571 InternalConstructor entity = (InternalConstructor)node.Entity;
572 ProcessMethodBody(entity);
573
574 if (node.IsRuntime)
575 {
576 CheckRuntimeMethod(node);
577 }
578 else
579 {
580 if (entity.DeclaringType.IsValueType)
581 {
582 if (0 == node.Parameters.Count &&
583 !node.IsSynthetic)
584 {
585 Error(
586 CompilerErrorFactory.ValueTypesCannotDeclareParameterlessConstructors(node));
587 }
588 }
589 else if (
590 !entity.HasSelfCall &&
591 !entity.HasSuperCall &&
592 !entity.IsStatic)
593 {
594 IType baseType = entity.DeclaringType.BaseType;
595 IConstructor super = GetCorrectConstructor(node, baseType, EmptyExpressionCollection);
596 if (null != super)
597 {
598 node.Body.Statements.Insert(0,
599 CodeBuilder.CreateSuperConstructorInvocation(super));
600 }
601 }
602 }
603 }
604
605 override public void LeaveParameterDeclaration(ParameterDeclaration node)
606 {
607 AssertIdentifierName(node, node.Name);
608 CheckParameterType(node.Type);
609 }
610
611 void CheckParameterType(TypeReference type)
612 {
613 if (type.Entity != TypeSystemServices.VoidType) return;
614 Error(CompilerErrorFactory.InvalidParameterType(type, type.Entity.ToString()));
615 }
616
617 void CheckFieldType(TypeReference type)
618 {
619 if (type.Entity != TypeSystemServices.VoidType) return;
620 Error(CompilerErrorFactory.InvalidFieldType(type, type.Entity.ToString()));
621 }
622
623 void CheckDeclarationType(TypeReference type)
624 {
625 if (type.Entity != TypeSystemServices.VoidType) return;
626 Error(CompilerErrorFactory.InvalidDeclarationType(type, type.Entity.ToString()));
627 }
628
629 override public void OnBlockExpression(BlockExpression node)
630 {
631 if (WasVisited(node)) return;
632 MarkVisited(node);
633
634 Method closure = CodeBuilder.CreateMethod(
635 ClosureNameFor(node),
636 Unknown.Default,
637 ClosureModifiers());
638
639 MarkVisited(closure);
640
641 InternalMethod closureEntity = (InternalMethod)closure.Entity;
642 closure.LexicalInfo = node.LexicalInfo;
643 closure.Parameters = node.Parameters;
644 closure.Body = node.Body;
645
646 _currentMethod.Method.DeclaringType.Members.Add(closure);
647
648 CodeBuilder.BindParameterDeclarations(_currentMethod.IsStatic, closure);
649
650 // check for invalid names and
651 // resolve parameter types
652 Visit(closure.Parameters);
653
654 if (node.ContainsAnnotation("inline"))
655 {
656 AddOptionalReturnStatement(node.Body);
657 }
658
659 // Connects the closure method namespace with the current
660 NamespaceDelegator ns = new NamespaceDelegator(CurrentNamespace, closureEntity);
661 ProcessMethodBody(closureEntity, ns);
662 TryToResolveReturnType(closureEntity);
663
664 node.ExpressionType = closureEntity.Type;
665 node.Entity = closureEntity;
666 }
667
668 private TypeMemberModifiers ClosureModifiers()
669 {
670 TypeMemberModifiers modifiers = TypeMemberModifiers.Internal;
671 if (_currentMethod.IsStatic)
672 {
673 modifiers |= TypeMemberModifiers.Static;
674 }
675 return modifiers;
676 }
677
678 private string ClosureNameFor(BlockExpression block)
679 {
680 string closureHint = (block["ClosureName"] as string) ?? "closure";
681 return _currentMethod.Name + "$" + closureHint + "$" + _context.AllocIndex();
682 }
683
684 private void AddOptionalReturnStatement(Block body)
685 {
686 if (body.Statements.Count != 1) return;
687 ExpressionStatement stmt = body.Statements[0] as ExpressionStatement;
688 if (null == stmt) return;
689
690 ReturnStatement rs = new ReturnStatement(stmt.LexicalInfo, stmt.Expression, null);
691 rs.Annotate(OptionalReturnStatementAnnotation);
692 body.Replace(stmt, rs);
693 }
694
695 override public void OnMethod(Method method)
696 {
697 if (WasVisited(method)) return;
698 MarkVisited(method);
699
700 Visit(method.Attributes);
701 Visit(method.Parameters);
702 Visit(method.ReturnType);
703 Visit(method.ReturnTypeAttributes);
704
705 bool ispinvoke = GetEntity(method).IsPInvoke;
706 if (method.IsRuntime || ispinvoke)
707 {
708 CheckRuntimeMethod(method);
709 if (ispinvoke)
710 {
711 method.Modifiers |= TypeMemberModifiers.Static;
712 }
713 }
714 else
715 {
716 try
717 {
718 PushMember(method);
719 ProcessRegularMethod(method);
720 }
721 finally
722 {
723 PopMember();
724 }
725 }
726 }
727
728 void CheckIfIsMethodOverride(InternalMethod entity)
729 {
730 if (entity.IsStatic) return;
731
732 IMethod overriden = FindMethodOverride(entity);
733 if (null == overriden) return;
734
735 ProcessMethodOverride(entity, overriden);
736 }
737
738 IMethod FindPropertyAccessorOverride(Property property, Method accessor)
739 {
740 IProperty baseProperty = ((InternalProperty)property.Entity).Override;
741 if (null == baseProperty) return null;
742
743 IMethod baseMethod = null;
744 if (property.Getter == accessor)
745 {
746 baseMethod = baseProperty.GetGetMethod();
747 }
748 else
749 {
750 baseMethod = baseProperty.GetSetMethod();
751 }
752
753 if (null != baseMethod)
754 {
755 IMethod accessorEntity = (IMethod)accessor.Entity;
756 if (TypeSystemServices.CheckOverrideSignature(accessorEntity, baseMethod))
757 {
758 return baseMethod;
759 }
760 }
761
762 return null;
763 }
764
765 IMethod FindMethodOverride(InternalMethod entity)
766 {
767 Method method = entity.Method;
768 if (NodeType.Property == method.ParentNode.NodeType)
769 {
770 return FindPropertyAccessorOverride((Property)method.ParentNode, method);
771 }
772
773 IType baseType = entity.DeclaringType.BaseType;
774 IEntity candidates = NameResolutionService.Resolve(baseType, entity.Name, EntityType.Method);
775 if (null != candidates)
776 {
777 IMethod baseMethod = null;
778 if (EntityType.Method == candidates.EntityType)
779 {
780 IMethod candidate = (IMethod)candidates;
781 if (TypeSystemServices.CheckOverrideSignature(entity, candidate))
782 {
783 baseMethod = candidate;
784 }
785 }
786 else if (EntityType.Ambiguous == candidates.EntityType)
787 {
788 IEntity[] entities = ((Ambiguous)candidates).Entities;
789 foreach (IMethod candidate in entities)
790 {
791 if (TypeSystemServices.CheckOverrideSignature(entity, candidate))
792 {
793 baseMethod = candidate;
794 break;
795 }
796 }
797 }
798 if (null != baseMethod)
799 {
800 EnsureRelatedNodeWasVisited(method, baseMethod);
801 }
802 return baseMethod;
803 }
804 return null;
805 }
806
807 void ResolveMethodOverride(InternalMethod entity)
808 {
809 IMethod baseMethod = FindMethodOverride(entity);
810 if (null == baseMethod)
811 {
812 Error(CompilerErrorFactory.NoMethodToOverride(entity.Method, entity.ToString()));
813 }
814 else
815 {
816 if (!baseMethod.IsVirtual)
817 {
818 CantOverrideNonVirtual(entity.Method, baseMethod);
819 }
820 else
821 {
822 ProcessMethodOverride(entity, baseMethod);
823 }
824 }
825 }
826
827 void ProcessMethodOverride(InternalMethod entity, IMethod baseMethod)
828 {
829 if (TypeSystemServices.IsUnknown(entity.ReturnType))
830 {
831 entity.Method.ReturnType = CodeBuilder.CreateTypeReference(entity.Method.LexicalInfo, baseMethod.ReturnType);
832 }
833 else
834 {
835 if (baseMethod.ReturnType != entity.ReturnType)
836 {
837 Error(CompilerErrorFactory.InvalidOverrideReturnType(
838 entity.Method.ReturnType,
839 baseMethod.FullName,
840 baseMethod.ReturnType.ToString(),
841 entity.ReturnType.ToString()));
842 }
843 }
844 SetOverride(entity, baseMethod);
845 }
846
847 void CantOverrideNonVirtual(Method method, IMethod baseMethod)
848 {
849 Error(CompilerErrorFactory.CantOverrideNonVirtual(method, baseMethod.ToString()));
850 }
851
852 void SetPropertyAccessorOverride(Method accessor)
853 {
854 if (null != accessor)
855 {
856 accessor.Modifiers |= TypeMemberModifiers.Override;
857 }
858 }
859
860 IProperty ResolvePropertyOverride(IProperty p, IEntity[] candidates)
861 {
862 foreach (IEntity candidate in candidates)
863 {
864 if (EntityType.Property != candidate.EntityType) continue;
865 IProperty candidateProperty = (IProperty)candidate;
866 if (CheckOverrideSignature(p, candidateProperty))
867 {
868 return candidateProperty;
869 }
870 }
871 return null;
872 }
873
874 bool CheckOverrideSignature(IProperty p, IProperty candidate)
875 {
876 return TypeSystemServices.CheckOverrideSignature(p.GetParameters(), candidate.GetParameters());
877 }
878
879 void ResolvePropertyOverride(Property property)
880 {
881 InternalProperty entity = (InternalProperty)property.Entity;
882 IType baseType = entity.DeclaringType.BaseType;
883 IEntity baseProperties = NameResolutionService.Resolve(baseType, property.Name, EntityType.Property);
884 if (null != baseProperties)
885 {
886 if (EntityType.Property == baseProperties.EntityType)
887 {
888 IProperty candidate = (IProperty)baseProperties;
889 if (CheckOverrideSignature(entity, candidate))
890 {
891 entity.Override = candidate;
892 }
893 }
894 else if (EntityType.Ambiguous == baseProperties.EntityType)
895 {
896 entity.Override = ResolvePropertyOverride(entity, ((Ambiguous)baseProperties).Entities);
897 }
898 }
899
900 if (null != entity.Override)
901 {
902 EnsureRelatedNodeWasVisited(property, entity.Override);
903 if (property.IsOverride)
904 {
905 SetPropertyAccessorOverride(property.Getter);
906 SetPropertyAccessorOverride(property.Setter);
907 }
908 else
909 {
910 if (null != entity.Override.GetGetMethod())
911 {
912 SetPropertyAccessorOverride(property.Getter);
913 }
914 if (null != entity.Override.GetSetMethod())
915 {
916 SetPropertyAccessorOverride(property.Setter);
917 }
918 }
919
920 if (null == property.Type)
921 {
922 property.Type = CodeBuilder.CreateTypeReference(entity.Override.Type);
923 }
924 }
925 }
926
927 void SetOverride(InternalMethod entity, IMethod baseMethod)
928 {
929 TraceOverride(entity.Method, baseMethod);
930
931 entity.Overriden = baseMethod;
932 entity.Method.Modifiers |= TypeMemberModifiers.Override;
933 }
934
935
936 void TraceOverride(Method method, IMethod baseMethod)
937 {
938 _context.TraceInfo("{0}: Method '{1}' overrides '{2}'", method.LexicalInfo, method.Name, baseMethod);
939 }
940
941 class ReturnExpressionFinder : DepthFirstVisitor
942 {
943 bool _hasReturnStatements = false;
944
945 bool _hasYieldStatements = false;
946
947 public ReturnExpressionFinder(Method node)
948 {
949 Visit(node.Body);
950 }
951
952 public bool HasReturnStatements
953 {
954 get
955 {
956 return _hasReturnStatements;
957 }
958 }
959
960 public bool HasYieldStatements
961 {
962 get
963 {
964 return _hasYieldStatements;
965 }
966 }
967
968 public override void OnReturnStatement(ReturnStatement node)
969 {
970 _hasReturnStatements |= (null != node.Expression);
971 }
972
973 public override void OnYieldStatement(YieldStatement node)
974 {
975 _hasYieldStatements = true;
976 }
977 }
978
979 bool DontHaveReturnExpressionsNorYield(Method node)
980 {
981 ReturnExpressionFinder finder = new ReturnExpressionFinder(node);
982 return !(finder.HasReturnStatements || finder.HasYieldStatements);
983 }
984
985 void PreProcessMethod(Method node)
986 {
987 if (WasAlreadyPreProcessed(node)) return;
988 MarkPreProcessed(node);
989
990 InternalMethod entity = (InternalMethod)GetEntity(node);
991 if (node.IsOverride)
992 {
993 ResolveMethodOverride(entity);
994 }
995 else
996 {
997 CheckIfIsMethodOverride(entity);
998 if (TypeSystemServices.IsUnknown(entity.ReturnType))
999 {
1000 if (DontHaveReturnExpressionsNorYield(node))
1001 {
1002 node.ReturnType = CodeBuilder.CreateTypeReference(node.LexicalInfo, TypeSystemServices.VoidType);
1003 }
1004 }
1005 }
1006 }
1007
1008 static readonly object PreProcessedKey = new object();
1009
1010 private bool WasAlreadyPreProcessed(Method node)
1011 {
1012 return node.ContainsAnnotation(PreProcessedKey);
1013 }
1014
1015 private void MarkPreProcessed(Method node)
1016 {
1017 node[PreProcessedKey] = PreProcessedKey;
1018 }
1019
1020 void ProcessRegularMethod(Method node)
1021 {
1022 PreProcessMethod(node);
1023
1024 InternalMethod entity = (InternalMethod) GetEntity(node);
1025 ProcessMethodBody(entity);
1026
1027 PostProcessMethod(node);
1028 }
1029
1030 private void PostProcessMethod(Method node)
1031 {
1032 bool parentIsClass = node.DeclaringType.NodeType == NodeType.ClassDefinition;
1033 if (!parentIsClass) return;
1034
1035 InternalMethod entity = (InternalMethod)GetEntity(node);
1036 if (TypeSystemServices.IsUnknown(entity.ReturnType))
1037 {
1038 TryToResolveReturnType(entity);
1039 }
1040 else
1041 {
1042 if (entity.IsGenerator)
1043 {
1044 CheckGeneratorReturnType(node, entity.ReturnType);
1045 CheckGeneratorYieldType(entity, entity.ReturnType);
1046 }
1047 }
1048 CheckGeneratorCantReturnValues(entity);
1049 }
1050
1051 void CheckGeneratorCantReturnValues(InternalMethod entity)
1052 {
1053 if (!entity.IsGenerator) return;
1054 if (null == entity.ReturnExpressions) return;
1055
1056 foreach (Expression e in entity.ReturnExpressions)
1057 {
1058 Error(CompilerErrorFactory.GeneratorCantReturnValue(e));
1059 }
1060 }
1061
1062 void CheckGeneratorReturnType(Method method, IType returnType)
1063 {
1064 bool validReturnType =
1065 (TypeSystemServices.IEnumerableType == returnType ||
1066 TypeSystemServices.IEnumeratorType == returnType ||
1067 TypeSystemServices.IsSystemObject(returnType) ||
1068 CheckGenericGeneratorReturnType(returnType));
1069
1070 if (!validReturnType)
1071 {
1072 Error(CompilerErrorFactory.InvalidGeneratorReturnType(method.ReturnType));
1073 }
1074 }
1075
1076 bool CheckGenericGeneratorReturnType(IType returnType)
1077 {
1078 return returnType.ConstructedInfo != null &&
1079 (returnType.ConstructedInfo.GenericDefinition == TypeSystemServices.IEnumerableGenericType ||
1080 returnType.ConstructedInfo.GenericDefinition == TypeSystemServices.IEnumeratorGenericType);
1081 }
1082
1083 void CheckGeneratorYieldType(InternalMethod method, IType returnType)
1084 {
1085 if (CheckGenericGeneratorReturnType(returnType))
1086 {
1087 IType returnElementType = returnType.ConstructedInfo.GenericArguments[0];
1088
1089 foreach (Expression yieldExpression in method.YieldExpressions)
1090 {
1091 IType yieldType = yieldExpression.ExpressionType;
1092 if (!returnElementType.IsAssignableFrom(yieldType) &&
1093 !TypeSystemServices.CanBeReachedByDownCastOrPromotion(returnElementType, yieldType))
1094 {
1095 Error(CompilerErrorFactory.YieldTypeDoesNotMatchReturnType(
1096 yieldExpression, yieldType.ToString(), returnElementType.ToString()));
1097 }
1098 }
1099 }
1100 }
1101
1102 void ProcessMethodBody(InternalMethod entity)
1103 {
1104 ProcessMethodBody(entity, entity);
1105 }
1106
1107 void ProcessMethodBody(InternalMethod entity, INamespace ns)
1108 {
1109 ProcessNodeInMethodContext(entity, ns, entity.Method.Body);
1110 if (entity.IsGenerator) CreateGeneratorSkeleton(entity);
1111 }
1112
1113 void ProcessNodeInMethodContext(InternalMethod entity, INamespace ns, Node node)
1114 {
1115 PushMethodInfo(entity);
1116 EnterNamespace(ns);
1117 try
1118 {
1119 Visit(node);
1120 }
1121 finally
1122 {
1123 LeaveNamespace();
1124 PopMethodInfo();
1125 }
1126 }
1127
1128 void ResolveGeneratorReturnType(InternalMethod entity)
1129 {
1130 Method method = entity.Method;
1131
1132 // Make method return a generic IEnumerable
1133 IType itemType = (IType)method["GeneratorItemType"];
1134 if (TypeSystemServices.VoidType == itemType)
1135 {
1136 // circunvent exception in MakeGenericType
1137 method.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.ErrorEntity);
1138 return;
1139 }
1140
1141 IType returnType = GetGeneratorReturnType(itemType);
1142 method.ReturnType = CodeBuilder.CreateTypeReference(returnType);
1143 }
1144
1145
1146 protected virtual IType GetGeneratorReturnType(IType itemType)
1147 {
1148 IType enumerableType = TypeSystemServices.IEnumerableGenericType;
1149 return enumerableType.GenericInfo.ConstructType(itemType);
1150 }
1151
1152 void TryToResolveReturnType(InternalMethod entity)
1153 {
1154 if (entity.IsGenerator)
1155 {
1156 ResolveGeneratorReturnType(entity);
1157 }
1158 else
1159 {
1160 if (CanResolveReturnType(entity))
1161 {
1162 ResolveReturnType(entity);
1163 }
1164 }
1165 }
1166
1167 override public void OnSuperLiteralExpression(SuperLiteralExpression node)
1168 {
1169 if (!AstUtil.IsTargetOfMethodInvocation(node))
1170 {
1171 node.ExpressionType = _currentMethod.DeclaringType.BaseType;
1172 return;
1173 }
1174
1175 if (EntityType.Constructor == _currentMethod.EntityType)
1176 {
1177 // TODO: point to super ctor
1178 node.Entity = _currentMethod;
1179 return;
1180 }
1181
1182 if (null == _currentMethod.Overriden)
1183 {
1184 Error(node,
1185 CompilerErrorFactory.MethodIsNotOverride(node, _currentMethod.ToString()));
1186 return;
1187 }
1188
1189 node.Entity = _currentMethod;
1190 }
1191
1192 bool CanResolveReturnType(InternalMethod tag)
1193 {
1194 ExpressionCollection expressions = tag.ReturnExpressions;
1195 if (null != expressions)
1196 {
1197 foreach (Expression expression in expressions)
1198 {
1199 IType type = expression.ExpressionType;
1200 if (null == type || TypeSystemServices.IsUnknown(type))
1201 {
1202 return false;
1203 }
1204 }
1205 }
1206 return true;
1207 }
1208
1209 TypeReference GetMostGenericTypeReference(ExpressionCollection expressions)
1210 {
1211 IType type = MapNullToObject(GetMostGenericType(expressions));
1212 return CodeBuilder.CreateTypeReference(type);
1213 }
1214
1215 void ResolveReturnType(InternalMethod entity)
1216 {
1217 Method method = entity.Method;
1218 if (null == entity.ReturnExpressions)
1219 {
1220 method.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType);
1221 }
1222 else
1223 {
1224 method.ReturnType = GetMostGenericTypeReference(entity.ReturnExpressions);
1225 }
1226 TraceReturnType(method, entity);
1227 }
1228
1229 IType MapNullToObject(IType type)
1230 {
1231 if (Null.Default == type)
1232 {
1233 return TypeSystemServices.ObjectType;
1234 }
1235 return type;
1236 }
1237
1238 IType GetMostGenericType(IType lhs, IType rhs)
1239 {
1240 return TypeSystemServices.GetMostGenericType(lhs, rhs);
1241 }
1242
1243 IType GetMostGenericType(ExpressionCollection args)
1244 {
1245 IType type = GetConcreteExpressionType(args[0]);
1246 for (int i=1; i<args.Count; ++i)
1247 {
1248 IType newType = GetConcreteExpressionType(args[i]);
1249
1250 if (type == newType)
1251 {
1252 continue;
1253 }
1254
1255 type = GetMostGenericType(type, newType);
1256 if (TypeSystemServices.IsSystemObject(type))
1257 {
1258 break;
1259 }
1260 }
1261 return type;
1262 }
1263
1264 override public void OnBoolLiteralExpression(BoolLiteralExpression node)
1265 {
1266 BindExpressionType(node, TypeSystemServices.BoolType);
1267 }
1268
1269 override public void OnTimeSpanLiteralExpression(TimeSpanLiteralExpression node)
1270 {
1271 BindExpressionType(node, TypeSystemServices.TimeSpanType);
1272 }
1273
1274 override public void OnIntegerLiteralExpression(IntegerLiteralExpression node)
1275 {
1276 if (node.IsLong)
1277 {
1278 BindExpressionType(node, TypeSystemServices.LongType);
1279 }
1280 else
1281 {
1282 BindExpressionType(node, TypeSystemServices.IntType);
1283 }
1284 }
1285
1286 override public void OnDoubleLiteralExpression(DoubleLiteralExpression node)
1287 {
1288 BindExpressionType(node, node.IsSingle ? TypeSystemServices.SingleType : TypeSystemServices.DoubleType);
1289 }
1290
1291 override public void OnStringLiteralExpression(StringLiteralExpression node)
1292 {
1293 BindExpressionType(node, TypeSystemServices.StringType);
1294 }
1295
1296 override public void OnCharLiteralExpression(CharLiteralExpression node)
1297 {
1298 string value = node.Value;
1299 if (null == value || 1 != value.Length)
1300 {
1301 Errors.Add(CompilerErrorFactory.InvalidCharLiteral(node, value));
1302 }
1303 BindExpressionType(node, TypeSystemServices.CharType);
1304 }
1305
1306 IEntity[] GetSetMethods(IEntity[] entities)
1307 {
1308 List setMethods = new List();
1309 for (int i=0; i<entities.Length; ++i)
1310 {
1311 IProperty property = entities[i] as IProperty;
1312 if (null != property)
1313 {
1314 IMethod setter = property.GetSetMethod();
1315 if (null != setter)
1316 {
1317 setMethods.AddUnique(setter);
1318 }
1319 }
1320 }
1321 return ToEntityArray(setMethods);
1322 }
1323
1324 IEntity[] GetGetMethods(IEntity[] entities)
1325 {
1326 List getMethods = new List();
1327 for (int i=0; i<entities.Length; ++i)
1328 {
1329 IProperty property = entities[i] as IProperty;
1330 if (null != property)
1331 {
1332 IMethod getter = property.GetGetMethod();
1333 if (null != getter)
1334 {
1335 getMethods.AddUnique(getter);
1336 }
1337 }
1338 }
1339 return ToEntityArray(getMethods);
1340 }
1341
1342 private static IEntity[] ToEntityArray(List entities)
1343 {
1344 return (IEntity[])entities.ToArray(new IEntity[entities.Count]);
1345 }
1346
1347 void CheckNoComplexSlicing(SlicingExpression node)
1348 {
1349 if (AstUtil.IsComplexSlicing(node))
1350 {
1351 NotImplemented(node, "complex slicing");
1352 }
1353 }
1354
1355 protected MethodInvocationExpression CreateEquals(BinaryExpression node)
1356 {
1357 return CodeBuilder.CreateMethodInvocation(RuntimeServices_EqualityOperator, node.Left, node.Right);
1358 }
1359
1360 IntegerLiteralExpression CreateIntegerLiteral(long value)
1361 {
1362 IntegerLiteralExpression expression = new IntegerLiteralExpression(value);
1363 Visit(expression);
1364 return expression;
1365 }
1366
1367 bool CheckComplexSlicingParameters(SlicingExpression node)
1368 {
1369 foreach (Slice slice in node.Indices)
1370 {
1371 if (!CheckComplexSlicingParameters(slice))
1372 {
1373 return false;
1374 }
1375 }
1376 return true;
1377 }
1378
1379 bool CheckComplexSlicingParameters(Slice node)
1380 {
1381 if (null != node.Step)
1382 {
1383 NotImplemented(node, "slicing step");
1384 return false;
1385 }
1386
1387 if (OmittedExpression.Default == node.Begin)
1388 {
1389 node.Begin = CreateIntegerLiteral(0);
1390 }
1391 else
1392 {
1393 if (!AssertTypeCompatibility(node.Begin, TypeSystemServices.IntType, GetExpressionType(node.Begin)))
1394 {
1395 return false;
1396 }
1397 }
1398
1399 if (null != node.End && OmittedExpression.Default != node.End)
1400 {
1401 if (!AssertTypeCompatibility(node.End, TypeSystemServices.IntType, GetExpressionType(node.End)))
1402 {
1403 return false;
1404 }
1405 }
1406
1407 return true;
1408 }
1409
1410 void BindComplexListSlicing(SlicingExpression node)
1411 {
1412 Slice slice = node.Indices[0];
1413
1414 if (CheckComplexSlicingParameters(slice))
1415 {
1416 MethodInvocationExpression mie = null;
1417
1418 if (null == slice.End || slice.End == OmittedExpression.Default)
1419 {
1420 mie = CodeBuilder.CreateMethodInvocation(node.Target, List_GetRange1);
1421 mie.Arguments.Add(slice.Begin);
1422 }
1423 else
1424 {
1425 mie = CodeBuilder.CreateMethodInvocation(node.Target, List_GetRange2);
1426 mie.Arguments.Add(slice.Begin);
1427 mie.Arguments.Add(slice.End);
1428 }
1429 node.ParentNode.Replace(node, mie);
1430 }
1431 }
1432
1433 void BindComplexArraySlicing(SlicingExpression node)
1434 {
1435 if (AstUtil.IsLhsOfAssignment(node))
1436 {
1437 return;
1438 }
1439
1440 if (CheckComplexSlicingParameters(node))
1441 {
1442 if (node.Indices.Count > 1)
1443 {
1444 IArrayType arrayType = (IArrayType)GetExpressionType(node.Target);
1445 MethodInvocationExpression mie = null;
1446 ArrayLiteralExpression collapse = new ArrayLiteralExpression();
1447 ArrayLiteralExpression ranges = new ArrayLiteralExpression();
1448 int collapseCount = 0;
1449 for (int i = 0; i < node.Indices.Count; i++)
1450 {
1451 ranges.Items.Add(node.Indices[i].Begin);
1452 if (node.Indices[i].End == null ||
1453 node.Indices[i].End == OmittedExpression.Default)
1454 {
1455 BinaryExpression end = new BinaryExpression(BinaryOperatorType.Addition,
1456 node.Indices[i].Begin,
1457 new IntegerLiteralExpression(1));
1458 ranges.Items.Add(end);
1459 BindExpressionType(end, GetExpressionType(node.Indices[i].Begin));
1460 collapse.Items.Add(new BoolLiteralExpression(true));
1461 collapseCount++;
1462 }
1463 else
1464 {
1465 ranges.Items.Add(node.Indices[i].End);
1466 collapse.Items.Add(new BoolLiteralExpression(false));
1467 }
1468 }
1469 mie = CodeBuilder.CreateMethodInvocation(RuntimeServices_GetMultiDimensionalRange1, node.Target, ranges);
1470 mie.Arguments.Add(collapse);
1471
1472 BindExpressionType(ranges, TypeSystemServices.Map(typeof(int[])));
1473 BindExpressionType(collapse, TypeSystemServices.Map(typeof(bool[])));
1474 BindExpressionType(mie, TypeSystemServices.GetArrayType(arrayType.GetElementType(), node.Indices.Count - collapseCount));
1475 node.ParentNode.Replace(node, mie);
1476 }
1477 else
1478 {
1479 Slice slice = node.Indices[0];
1480
1481 if (CheckComplexSlicingParameters(slice))
1482 {
1483 MethodInvocationExpression mie = null;
1484
1485 if (null == slice.End || slice.End == OmittedExpression.Default)
1486 {
1487 mie = CodeBuilder.CreateMethodInvocation(RuntimeServices_GetRange1, node.Target, slice.Begin);
1488 }
1489 else
1490 {
1491 mie = CodeBuilder.CreateMethodInvocation(RuntimeServices_GetRange2, node.Target, slice.Begin, slice.End);
1492 }
1493
1494 BindExpressionType(mie, GetExpressionType(node.Target));
1495 node.ParentNode.Replace(node, mie);
1496 }
1497 }
1498 }
1499 }
1500
1501 bool NeedsNormalization(Expression index)
1502 {
1503 if (NodeType.IntegerLiteralExpression == index.NodeType)
1504 {
1505 return ((IntegerLiteralExpression)index).Value < 0;
1506 }
1507 return true;
1508 }
1509
1510 void BindComplexStringSlicing(SlicingExpression node)
1511 {
1512 Slice slice = node.Indices[0];
1513
1514 if (CheckComplexSlicingParameters(slice))
1515 {
1516 MethodInvocationExpression mie = null;
1517
1518 if (null == slice.End || slice.End == OmittedExpression.Default)
1519 {
1520 if (NeedsNormalization(slice.Begin))
1521 {
1522 mie = CodeBuilder.CreateEvalInvocation(node.LexicalInfo);
1523 mie.ExpressionType = TypeSystemServices.StringType;
1524
1525 InternalLocal temp = DeclareTempLocal(TypeSystemServices.StringType);
1526 mie.Arguments.Add(
1527 CodeBuilder.CreateAssignment(
1528 CodeBuilder.CreateReference(temp),
1529 node.Target));
1530
1531 mie.Arguments.Add(
1532 CodeBuilder.CreateMethodInvocation(
1533 CodeBuilder.CreateReference(temp),
1534 String_Substring_Int,
1535 CodeBuilder.CreateMethodInvocation(
1536 RuntimeServices_NormalizeStringIndex,
1537 CodeBuilder.CreateReference(temp),
1538 slice.Begin)));
1539 }
1540 else
1541 {
1542 mie = CodeBuilder.CreateMethodInvocation(node.Target, String_Substring_Int, slice.Begin);
1543 }
1544 }
1545 else
1546 {
1547 mie = CodeBuilder.CreateMethodInvocation(RuntimeServices_Mid, node.Target, slice.Begin, slice.End);
1548 }
1549
1550 node.ParentNode.Replace(node, mie);
1551 }
1552 }
1553
1554 bool IsIndexedProperty(Expression expression)
1555 {
1556 IEntity entity = expression.Entity;
1557 if (null != entity)
1558 {
1559 return IsIndexedProperty(entity);
1560 }
1561 return false;
1562 }
1563
1564 override public void LeaveSlicingExpression(SlicingExpression node)
1565 {
1566 if (IsAmbiguous(node.Target.Entity))
1567 {
1568 BindIndexedPropertySlicing(node);
1569 return;
1570 }
1571
1572 // target[indices]
1573 IType targetType = GetExpressionType(node.Target);
1574 if (TypeSystemServices.IsError(targetType))
1575 {
1576 Error(node);
1577 return;
1578 }
1579
1580 if (IsIndexedProperty(node.Target))
1581 {
1582 BindIndexedPropertySlicing(node);
1583 }
1584 else
1585 {
1586 if (targetType.IsArray)
1587 {
1588 IArrayType arrayType = (IArrayType)targetType;
1589 if (arrayType.GetArrayRank() != node.Indices.Count)
1590 {
1591 Error(node, CompilerErrorFactory.InvalidArrayRank(node, node.Target.ToString(), arrayType.GetArrayRank(), node.Indices.Count));
1592 }
1593
1594 if (AstUtil.IsComplexSlicing(node))
1595 {
1596 BindComplexArraySlicing(node);
1597 }
1598 else
1599 {
1600 if (arrayType.GetArrayRank() > 1)
1601 {
1602 BindMultiDimensionalArraySlicing(node);
1603 }
1604 else
1605 {
1606 BindExpressionType(node, arrayType.GetElementType());
1607 }
1608 }
1609 }
1610 else
1611 {
1612 if (AstUtil.IsComplexSlicing(node))
1613 {
1614 if (TypeSystemServices.StringType == targetType)
1615 {
1616 BindComplexStringSlicing(node);
1617 }
1618 else
1619 {
1620 if (TypeSystemServices.ListType.IsAssignableFrom(targetType))
1621 {
1622 BindComplexListSlicing(node);
1623 }
1624 else
1625 {
1626 NotImplemented(node, "complex slicing for anything but lists, arrays and strings");
1627 }
1628 }
1629 }
1630 else
1631 {
1632 IEntity member = targetType.GetDefaultMember();
1633 if (null == member)
1634 {
1635 Error(node, CompilerErrorFactory.TypeDoesNotSupportSlicing(node.Target, targetType.ToString()));
1636 }
1637 else
1638 {
1639 node.Target = new MemberReferenceExpression(node.LexicalInfo, node.Target, member.Name);
1640 node.Target.Entity = member;
1641 // to be resolved later
1642 node.Target.ExpressionType = Null.Default;
1643 SliceMember(node, member);
1644 }
1645 }
1646 }
1647 }
1648 }
1649
1650 private void BindIndexedPropertySlicing(SlicingExpression node)
1651 {
1652 CheckNoComplexSlicing(node);
1653 SliceMember(node, node.Target.Entity);
1654 }
1655
1656 private bool IsAmbiguous(IEntity entity)
1657 {
1658 return null != entity && EntityType.Ambiguous == entity.EntityType;
1659 }
1660
1661 bool IsIndexedProperty(IEntity tag)
1662 {
1663 return EntityType.Property == tag.EntityType &&
1664 ((IProperty)tag).GetParameters().Length > 0;
1665 }
1666
1667 void BindMultiDimensionalArraySlicing(SlicingExpression node)
1668 {
1669 if (AstUtil.IsLhsOfAssignment(node))
1670 {
1671 // leave it to LeaveBinaryExpression to resolve
1672 return;
1673 }
1674
1675 MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
1676 node.Target,
1677 TypeSystemServices.Map(
1678 typeof(Array).GetMethod("GetValue", new Type[] { typeof(int[]) })));
1679 for (int i = 0; i < node.Indices.Count; i++)
1680 {
1681 mie.Arguments.Add(node.Indices[i].Begin);
1682 }
1683
1684 IType elementType = node.Target.ExpressionType.GetElementType();
1685 node.ParentNode.Replace(node, CodeBuilder.CreateCast(elementType, mie));
1686 }
1687
1688 void SliceMember(SlicingExpression node, IEntity member)
1689 {
1690 EnsureRelatedNodeWasVisited(node, member);
1691 if (AstUtil.IsLhsOfAssignment(node))
1692 {
1693 // leave it to LeaveBinaryExpression to resolve
1694 Bind(node, member);
1695 return;
1696 }
1697
1698 MethodInvocationExpression mie = new MethodInvocationExpression(node.LexicalInfo);
1699 foreach (Slice index in node.Indices)
1700 {
1701 mie.Arguments.Add(index.Begin);
1702 }
1703
1704 IMethod getter = null;
1705 if (EntityType.Ambiguous == member.EntityType)
1706 {
1707 IEntity result = ResolveAmbiguousPropertyReference((ReferenceExpression)node.Target, (Ambiguous)member, mie.Arguments);
1708 IProperty found = result as IProperty;
1709 if (null != found)
1710 {
1711 getter = found.GetGetMethod();
1712 }
1713 else if (EntityType.Ambiguous == result.EntityType)
1714 {
1715 Error(node);
1716 return;
1717 }
1718 }
1719 else if (EntityType.Property == member.EntityType)
1720 {
1721 getter = ((IProperty)member).GetGetMethod();
1722 }
1723
1724 if (null != getter)
1725 {
1726 if (AssertParameters(node, getter, mie.Arguments))
1727 {
1728 Expression target = GetIndexedPropertySlicingTarget(node);
1729
1730 mie.Target = CodeBuilder.CreateMemberReference(target, getter);
1731 BindExpressionType(mie, getter.ReturnType);
1732
1733 node.ParentNode.Replace(node, mie);
1734 }
1735 else
1736 {
1737 Error(node);
1738 }
1739 }
1740 else
1741 {
1742 NotImplemented(node, "slice for anything but arrays and default properties");
1743 }
1744 }
1745
1746 private Expression GetIndexedPropertySlicingTarget(SlicingExpression node)
1747 {
1748 Expression target = node.Target;
1749 MemberReferenceExpression mre = target as MemberReferenceExpression;
1750 if (null != mre) return mre.Target;
1751 return CreateSelfReference();
1752 }
1753
1754 override public void LeaveExpressionInterpolationExpression(ExpressionInterpolationExpression node)
1755 {
1756 BindExpressionType(node, TypeSystemServices.StringType);
1757 }
1758
1759 override public void LeaveListLiteralExpression(ListLiteralExpression node)
1760 {
1761 BindExpressionType(node, TypeSystemServices.ListType);
1762 TypeSystemServices.MapToConcreteExpressionTypes(node.Items);
1763 }
1764
1765 override public void OnExtendedGeneratorExpression(ExtendedGeneratorExpression node)
1766 {
1767 BlockExpression block = new BlockExpression(node.LexicalInfo);
1768
1769 Block body = block.Body;
1770 Expression e = node.Items[0].Expression;
1771 foreach (GeneratorExpression ge in node.Items)
1772 {
1773 ForStatement fs = new ForStatement(ge.LexicalInfo);
1774 fs.Iterator = ge.Iterator;
1775 fs.Declarations = ge.Declarations;
1776
1777 body.Add(fs);
1778
1779 if (null == ge.Filter)
1780 {
1781 body = fs.Block;
1782 }
1783 else
1784 {
1785 fs.Block.Add(
1786 NormalizeStatementModifiers.MapStatementModifier(ge.Filter, out body));
1787 }
1788
1789
1790 }
1791 body.Add(new YieldStatement(e.LexicalInfo, e));
1792
1793 MethodInvocationExpression mie = new MethodInvocationExpression(node.LexicalInfo);
1794 mie.Target = block;
1795
1796 Node parentNode = node.ParentNode;
1797 bool isGenerator = AstUtil.IsListMultiGenerator(parentNode);
1798 parentNode.Replace(node, mie);
1799 mie.Accept(this);
1800
1801 if (isGenerator)
1802 {
1803 parentNode.ParentNode.Replace(
1804 parentNode,
1805 CodeBuilder.CreateConstructorInvocation(
1806 TypeSystemServices.Map(ProcessGenerators.List_IEnumerableConstructor),
1807 mie));
1808 }
1809 }
1810
1811 override public void OnGeneratorExpression(GeneratorExpression node)
1812 {
1813 Visit(node.Iterator);
1814 node.Iterator = ProcessIterator(node.Iterator, node.Declarations);
1815
1816 EnterNamespace(new DeclarationsNamespace(CurrentNamespace, TypeSystemServices, node.Declarations));
1817 Visit(node.Filter);
1818 Visit(node.Expression);
1819 LeaveNamespace();
1820
1821 BooClassBuilder generatorType = CreateGeneratorSkeleton(node);
1822
1823 BindExpressionType(node, generatorType.Entity);
1824 }
1825
1826 void CreateGeneratorSkeleton(InternalMethod entity)
1827 {
1828 Method method = entity.Method;
1829 IType itemType = GetGeneratorItemType(entity);
1830 BooClassBuilder builder = CreateGeneratorSkeleton(method, method, itemType);
1831 method.DeclaringType.Members.Add(builder.ClassDefinition);
1832 // TypeSystemServices.AddCompilerGeneratedType(builder.ClassDefinition);
1833 }
1834
1835 private IType GetGeneratorItemType(InternalMethod entity)
1836 {
1837 IType itemType = null;
1838
1839 if (CheckGenericGeneratorReturnType(entity.ReturnType))
1840 {
1841 itemType = entity.ReturnType.ConstructedInfo.GenericArguments[0];
1842 }
1843 if (itemType == null)
1844 {
1845 ExpressionCollection yieldExpressions = entity.YieldExpressions;
1846
1847 itemType = yieldExpressions.Count > 0
1848 ? GetMostGenericType(yieldExpressions)
1849 : TypeSystemServices.ObjectType;
1850 }
1851 return itemType;
1852 }
1853
1854 BooClassBuilder CreateGeneratorSkeleton(GeneratorExpression node)
1855 {
1856 BooClassBuilder builder = CreateGeneratorSkeleton(node, _currentMethod.Method, GetConcreteExpressionType(node.Expression));
1857 _currentMethod.Method.DeclaringType.Members.Add(builder.ClassDefinition);
1858 return builder;
1859 }
1860
1861 protected IType GetConstructedType(IType genericType, IType argType)
1862 {
1863 return genericType.GenericInfo.ConstructType(argType);
1864 }
1865
1866 BooClassBuilder CreateGeneratorSkeleton(Node sourceNode, Method method, IType generatorItemType)
1867 {
1868 // create the class skeleton for type inference to work
1869 BooClassBuilder builder = CodeBuilder.CreateClass(
1870 string.Format("{0}${1}", method.Name, _context.AllocIndex()),
1871 TypeMemberModifiers.Internal|TypeMemberModifiers.Final);
1872 builder.LexicalInfo = sourceNode.LexicalInfo;
1873 builder.AddAttribute(CodeBuilder.CreateAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)));
1874
1875 BooMethodBuilder getEnumeratorBuilder = null;
1876 if (generatorItemType != TypeSystemServices.VoidType)
1877 {
1878 builder.AddBaseType(
1879 TypeSystemServices.Map(typeof(GenericGenerator<>)).GenericInfo.ConstructType(generatorItemType));
1880
1881 getEnumeratorBuilder = builder.AddVirtualMethod(
1882 "GetEnumerator",
1883 TypeSystemServices.IEnumeratorGenericType.GenericInfo.ConstructType(generatorItemType));
1884
1885 getEnumeratorBuilder.Method.LexicalInfo = sourceNode.LexicalInfo;
1886 }
1887
1888 sourceNode["GeneratorClassBuilder"] = builder;
1889 sourceNode["GetEnumeratorBuilder"] = getEnumeratorBuilder;
1890 sourceNode["GeneratorItemType"] = generatorItemType;
1891
1892 return builder;
1893 }
1894
1895 override public void LeaveHashLiteralExpression(HashLiteralExpression node)
1896 {
1897 BindExpressionType(node, TypeSystemServices.HashType);
1898 foreach (ExpressionPair pair in node.Items)
1899 {
1900 GetConcreteExpressionType(pair.First);
1901 GetConcreteExpressionType(pair.Second);
1902 }
1903 }
1904
1905 override public void LeaveArrayLiteralExpression(ArrayLiteralExpression node)
1906 {
1907 TypeSystemServices.MapToConcreteExpressionTypes(node.Items);
1908 IArrayType type = InferArrayType(node);
1909 BindExpressionType(node, type);
1910 if (null == node.Type)
1911 {
1912 node.Type = (ArrayTypeReference)CodeBuilder.CreateTypeReference(type);
1913 }
1914 else
1915 {
1916 CheckItems(type.GetElementType(), node.Items);
1917 }
1918 }
1919
1920 private IArrayType InferArrayType(ArrayLiteralExpression node)
1921 {
1922 if (null != node.Type) return (IArrayType)node.Type.Entity;
1923 if (0 == node.Items.Count) return TypeSystemServices.ObjectArrayType;
1924 return TypeSystemServices.GetArrayType(GetMostGenericType(node.Items), 1);
1925 }
1926
1927 override public void LeaveDeclaration(Declaration node)
1928 {
1929 if (null == node.Type) return;
1930 CheckDeclarationType(node.Type);
1931 }
1932
1933 override public void LeaveDeclarationStatement(DeclarationStatement node)
1934 {
1935 IType type = GetDeclarationType(node);
1936
1937 AssertDeclarationName(node.Declaration);
1938
1939 IEntity localInfo = DeclareLocal(node, node.Declaration.Name, type);
1940 if (null != node.Initializer)
1941 {
1942 IType itype = GetExpressionType(node.Initializer);
1943 AssertTypeCompatibility(node.Initializer, type, itype);
1944
1945 if (TypeSystemServices.IsNullable(type) && !TypeSystemServices.IsNullable(itype))
1946 {
1947 BindNullableInitializer(node, node.Initializer, type);
1948 }
1949
1950 node.ReplaceBy(
1951 new ExpressionStatement(
1952 CodeBuilder.CreateAssignment(
1953 node.LexicalInfo,
1954 CodeBuilder.CreateReference(localInfo),
1955 node.Initializer)));
1956 }
1957 else
1958 {
1959 node.ReplaceBy(
1960 new ExpressionStatement(
1961 CreateDefaultLocalInitializer(node, localInfo)));
1962 }
1963 }
1964
1965 private IType GetDeclarationType(DeclarationStatement node)
1966 {
1967 if (null != node.Declaration.Type) return GetType(node.Declaration.Type);
1968
1969 return InferDeclarationType(node);
1970 }
1971
1972 private IType InferDeclarationType(DeclarationStatement node)
1973 {
1974 if (null == node.Initializer) return TypeSystemServices.ObjectType;
1975
1976 // The boo syntax does not require this check because
1977 // there's no way to create an untyped declaration statement.
1978 // This is here to support languages that do allow untyped variable
1979 // declarations (unityscript is such an example).
1980 return GetConcreteExpressionType(node.Initializer);
1981 }
1982
1983 virtual protected Expression CreateDefaultLocalInitializer(Node sourceNode, IEntity local)
1984 {
1985 return CodeBuilder.CreateDefaultInitializer(
1986 sourceNode.LexicalInfo,
1987 (InternalLocal)local);
1988 }
1989
1990 override public void LeaveExpressionStatement(ExpressionStatement node)
1991 {
1992 AssertHasSideEffect(node.Expression);
1993 }
1994
1995 override public void OnNullLiteralExpression(NullLiteralExpression node)
1996 {
1997 BindExpressionType(node, Null.Default);
1998 }
1999
2000 override public void OnSelfLiteralExpression(SelfLiteralExpression node)
2001 {
2002 if (null == _currentMethod)
2003 {
2004 Error(node, CompilerErrorFactory.SelfOutsideMethod(node));
2005 }
2006 else
2007 {
2008 if (_currentMethod.IsStatic)
2009 {
2010 if (NodeType.MemberReferenceExpression != node.ParentNode.NodeType)
2011 {
2012 // if we are inside a MemberReferenceExpression
2013 // let the MemberReferenceExpression deal with it
2014 // as it can provide a better message
2015 Error(CompilerErrorFactory.ObjectRequired(node));
2016 }
2017 }
2018 node.Entity = _currentMethod;
2019 node.ExpressionType = _currentMethod.DeclaringType;
2020 }
2021 }
2022
2023 override public void LeaveTypeofExpression(TypeofExpression node)
2024 {
2025 BindExpressionType(node, TypeSystemServices.TypeType);
2026 }
2027
2028 override public void LeaveCastExpression(CastExpression node)
2029 {
2030 IType fromType = GetExpressionType(node.Target);
2031 IType toType = GetType(node.Type);
2032 if (!TypeSystemServices.AreTypesRelated(toType, fromType) &&
2033 !(toType.IsInterface && !fromType.IsFinal) &&
2034 !(TypeSystemServices.IsIntegerNumber(toType) && TypeSystemServices.CanBeExplicitlyCastToInteger(fromType)) &&
2035 !(TypeSystemServices.IsIntegerNumber(fromType) && TypeSystemServices.CanBeExplicitlyCastToInteger(toType)))
2036 {
2037 IMethod explicitOperator = TypeSystemServices.FindExplicitConversionOperator(fromType, toType);
2038 if (null != explicitOperator)
2039 {
2040 node.ParentNode.Replace(
2041 node,
2042 CodeBuilder.CreateMethodInvocation(
2043 explicitOperator,
2044 node.Target));
2045 return;
2046 }
2047
2048 Error(
2049 CompilerErrorFactory.IncompatibleExpressionType(
2050 node,
2051 toType.ToString(),
2052 fromType.ToString()));
2053 }
2054 BindExpressionType(node, toType);
2055 }
2056
2057 override public void LeaveTryCastExpression(TryCastExpression node)
2058 {
2059 IType target = GetExpressionType(node.Target);
2060 IType toType = GetType(node.Type);
2061
2062 if (target.IsValueType)
2063 {
2064 Error(CompilerErrorFactory.CantCastToValueType(node.Target, target.ToString()));
2065 }
2066 else if (toType.IsValueType)
2067 {
2068 Error(CompilerErrorFactory.CantCastToValueType(node.Type, toType.ToString()));
2069 }
2070 BindExpressionType(node, toType);
2071 }
2072
2073 protected Expression CreateMemberReferenceTarget(Node sourceNode, IMember member)
2074 {
2075 Expression target = null;
2076
2077 if (member.IsStatic)
2078 {
2079 target = new ReferenceExpression(sourceNode.LexicalInfo, member.DeclaringType.FullName);
2080 Bind(target, member.DeclaringType);
2081 }
2082 else
2083 {
2084 //check if found entity can't possibly be a member of self:
2085 if (member.DeclaringType != CurrentType
2086 && !(CurrentType.IsSubclassOf(member.DeclaringType)))
2087 {
2088 Error(
2089 CompilerErrorFactory.InstanceRequired(sourceNode,
2090 member.DeclaringType.ToString(),
2091 member.Name));
2092 }
2093 target = new SelfLiteralExpression(sourceNode.LexicalInfo);
2094 }
2095 BindExpressionType(target, member.DeclaringType);
2096 return target;
2097 }
2098
2099 protected MemberReferenceExpression MemberReferenceFromReference(ReferenceExpression node, IMember member)
2100 {
2101 MemberReferenceExpression memberRef = new MemberReferenceExpression(node.LexicalInfo);
2102 memberRef.Name = node.Name;
2103 memberRef.Target = CreateMemberReferenceTarget(node, member);
2104 return memberRef;
2105 }
2106
2107 void ResolveMemberInfo(ReferenceExpression node, IMember member)
2108 {
2109 MemberReferenceExpression memberRef = MemberReferenceFromReference(node, member);
2110 Bind(memberRef, member);
2111 node.ParentNode.Replace(node, memberRef);
2112 Visit(memberRef);
2113 }
2114
2115 override public void OnRELiteralExpression(RELiteralExpression node)
2116 {
2117 if (null != node.Entity)
2118 {
2119 return;
2120 }
2121
2122 IType type = TypeSystemServices.RegexType;
2123 BindExpressionType(node, type);
2124
2125 if (NodeType.Field != node.ParentNode.NodeType)
2126 {
2127 ReplaceByStaticFieldReference(node, "$re$" + _context.AllocIndex(), type);
2128 }
2129 }
2130
2131 void ReplaceByStaticFieldReference(Expression node, string fieldName, IType type)
2132 {
2133 Node parent = node.ParentNode;
2134
2135 Field field = CodeBuilder.CreateField(fieldName, type);
2136 field.Modifiers = TypeMemberModifiers.Internal|TypeMemberModifiers.Static;
2137 field.Initializer = node;
2138
2139 _currentMethod.Method.DeclaringType.Members.Add(field);
2140 parent.Replace(node, CodeBuilder.CreateReference(field));
2141
2142 AddFieldInitializerToStaticConstructor(0, field);
2143 }
2144
2145 override public void LeaveGenericReferenceExpression(GenericReferenceExpression node)
2146 {
2147 if (node.Target.Entity == null || TypeSystemServices.IsError(node.Target.Entity))
2148 {
2149 BindExpressionType(node, TypeSystemServices.ErrorEntity);
2150 return;
2151 }
2152
2153 IEntity entity = NameResolutionService.ResolveGenericReferenceExpression(node, node.Target.Entity);
2154 Bind(node, entity);
2155
2156 if (node.Target.Entity.EntityType == EntityType.Type)
2157 {
2158 BindTypeReferenceExpressionType(node, (IType)entity);
2159 }
2160 else if (node.Target.Entity.EntityType == EntityType.Method)
2161 {
2162 BindExpressionType(node, ((IMethod)entity).Type);
2163 }
2164 }
2165
2166 override public void OnReferenceExpression(ReferenceExpression node)
2167 {
2168 if (AlreadyBound(node)) return;
2169
2170 IEntity entity = ResolveName(node, node.Name);
2171 if (null == entity)
2172 {
2173 Error(node);
2174 return;
2175 }
2176
2177 // BOO-314 - if we are trying to invoke
2178 // something, let's make sure it is
2179 // something callable, otherwise, let's
2180 // try to find something callable
2181 if (AstUtil.IsTargetOfMethodInvocation(node)
2182 && !IsCallableEntity(entity))
2183 {
2184 IEntity callable = ResolveCallable(node);
2185 if (null != callable) entity = callable;
2186 }
2187
2188 IMember member = entity as IMember;
2189 if (null != member)
2190 {
2191 if (IsExtensionMethod(member))
2192 {
2193 Bind(node, member);
2194 return;
2195 }
2196 ResolveMemberInfo(node, member);
2197 return;
2198 }
2199
2200 EnsureRelatedNodeWasVisited(node, entity);
2201 node.Entity = entity;
2202 PostProcessReferenceExpression(node);
2203 }
2204
2205 private static bool AlreadyBound(ReferenceExpression node)
2206 {
2207 return null != node.ExpressionType;
2208 }
2209
2210 private IEntity ResolveCallable(ReferenceExpression node)
2211 {
2212 return NameResolutionService.Resolve(node.Name,
2213 EntityType.Type
2214 | EntityType.Method
2215 | EntityType.BuiltinFunction
2216 | EntityType.Event);
2217 }
2218
2219 private bool IsCallableEntity(IEntity entity)
2220 {
2221 switch (entity.EntityType)
2222 {
2223 case EntityType.Method:
2224 case EntityType.Type:
2225 case EntityType.Event:
2226 case EntityType.BuiltinFunction:
2227 case EntityType.Constructor:
2228 return true;
2229
2230 case EntityType.Ambiguous:
2231 // let overload resolution deal with it
2232 return true;
2233 }
2234 ITypedEntity typed = entity as ITypedEntity;
2235 return null == typed ? false : TypeSystemServices.IsCallable(typed.Type);
2236 }
2237
2238 void PostProcessReferenceExpression(ReferenceExpression node)
2239 {
2240 IEntity tag = GetEntity(node);
2241 switch (tag.EntityType)
2242 {
2243 case EntityType.Type:
2244 {
2245 BindTypeReferenceExpressionType(node, (IType)tag);
2246 break;
2247 }
2248
2249 case EntityType.Ambiguous:
2250 {
2251 tag = ResolveAmbiguousReference(node, (Ambiguous)tag);
2252 IMember resolvedMember = tag as IMember;
2253 if (null != resolvedMember)
2254 {
2255 ResolveMemberInfo(node, resolvedMember);
2256 break;
2257 }
2258 if (tag is IType)
2259 {
2260 BindTypeReferenceExpressionType(node, (IType)tag);
2261 break;
2262 }
2263 if (!AstUtil.IsTargetOfMethodInvocation(node)
2264 && !AstUtil.IsTargetOfSlicing(node)
2265 && !AstUtil.IsLhsOfAssignment(node))
2266 {
2267 Error(node, CompilerErrorFactory.AmbiguousReference(
2268 node,
2269 node.Name,
2270 ((Ambiguous)tag).Entities));
2271 }
2272 break;
2273 }
2274
2275 case EntityType.Namespace:
2276 {
2277 if (IsStandaloneReference(node))
2278 {
2279 Error(node, CompilerErrorFactory.NamespaceIsNotAnExpression(node, tag.Name));
2280 }
2281 break;
2282 }
2283
2284 case EntityType.Parameter:
2285 case EntityType.Local:
2286 {
2287 ILocalEntity local = (ILocalEntity)node.Entity;
2288 local.IsUsed = true;
2289 BindExpressionType(node, local.Type);
2290 break;
2291 }
2292
2293 default:
2294 {
2295 if (EntityType.BuiltinFunction == tag.EntityType)
2296 {
2297 CheckBuiltinUsage(node, tag);
2298 }
2299 else
2300 {
2301 if (node.ExpressionType == null)
2302 {
2303 BindExpressionType(node, ((ITypedEntity)tag).Type);
2304 }
2305 }
2306 break;
2307 }
2308 }
2309 }
2310
2311 protected virtual void BindTypeReferenceExpressionType(Expression node, IType type)
2312 {
2313 if (IsStandaloneReference(node))
2314 {
2315 BindExpressionType(node, TypeSystemServices.TypeType);
2316 }
2317 else
2318 {
2319 BindExpressionType(node, type);
2320 }
2321 }
2322
2323 protected virtual void CheckBuiltinUsage(ReferenceExpression node, IEntity entity)
2324 {
2325 if (!AstUtil.IsTargetOfMethodInvocation(node))
2326 {
2327 Error(node, CompilerErrorFactory.BuiltinCannotBeUsedAsExpression(node, entity.Name));
2328 }
2329 }
2330
2331 override public bool EnterMemberReferenceExpression(MemberReferenceExpression node)
2332 {
2333 return null == node.ExpressionType;
2334 }
2335
2336 INamespace GetReferenceNamespace(MemberReferenceExpression expression)
2337 {
2338 Expression target = expression.Target;
2339 INamespace ns = target.ExpressionType;
2340 if (null != ns)
2341 {
2342 return GetConcreteExpressionType(target);
2343 }
2344 return (INamespace)GetEntity(target);
2345 }
2346
2347 protected virtual void LeaveExplodeExpression(UnaryExpression node)
2348 {
2349 IType type = GetConcreteExpressionType(node.Operand);
2350 if (!type.IsArray)
2351 {
2352 Error(CompilerErrorFactory.ExplodedExpressionMustBeArray(node));
2353 }
2354 BindExpressionType(node, type);
2355 }
2356
2357 override public void LeaveMemberReferenceExpression(MemberReferenceExpression node)
2358 {
2359 _context.TraceVerbose("LeaveMemberReferenceExpression: {0}", node);
2360
2361 if (TypeSystemServices.IsError(node.Target))
2362 {
2363 Error(node);
2364 }
2365 else
2366 {
2367 ProcessMemberReferenceExpression(node);
2368 }
2369 }
2370
2371 virtual protected void MemberNotFound(MemberReferenceExpression node, INamespace ns)
2372 {
2373 EntityType et = (!AstUtil.IsTargetOfMethodInvocation(node)) ? EntityType.Any : EntityType.Method;
2374 Error(node,
2375 CompilerErrorFactory.MemberNotFound(node,
2376 (((IEntity)ns).ToString()),
2377 NameResolutionService.GetMostSimilarMemberName(ns, node.Name, et)));
2378 }
2379
2380 virtual protected bool ShouldRebindMember(IEntity entity)
2381 {
2382 return entity == null;
2383 }
2384
2385 IEntity ResolveMember(MemberReferenceExpression node)
2386 {
2387 IEntity member = node.Entity;
2388 if (!ShouldRebindMember(member)) return member;
2389
2390 INamespace ns = GetReferenceNamespace(node);
2391 member = NameResolutionService.Resolve(ns, node.Name);
2392 if (null != member)
2393 {
2394 IAccessibleMember accessible = member as IAccessibleMember;
2395 if (null != accessible && !IsAccessible(accessible))
2396 {
2397 IEntity extension = NameResolutionService.ResolveExtension(ns, node.Name);
2398 if (null != extension) return extension;
2399 }
2400 return member;
2401 }
2402
2403 member = NameResolutionService.ResolveExtension(ns, node.Name);
2404 if (null == member) MemberNotFound(node, ns);
2405
2406 return member;
2407 }
2408
2409 virtual protected void ProcessMemberReferenceExpression(MemberReferenceExpression node)
2410 {
2411 IEntity member = ResolveMember(node);
2412 if (null == member) return;
2413
2414 if (EntityType.Ambiguous == member.EntityType)
2415 {
2416 member = ResolveAmbiguousReference(node, (Ambiguous)member);
2417 }
2418
2419 EnsureRelatedNodeWasVisited(node, member);
2420
2421 if (EntityType.Namespace == member.EntityType)
2422 {
2423 string ns = null;
2424 foreach (Import import in _currentModule.Imports)
2425 {
2426 if (import.NamespaceUsed) continue;
2427 if (null == ns) ns = node.ToCodeString();
2428 if (import.Namespace == ns)
2429 {
2430 import.NamespaceUsed = true;
2431 break;
2432 }
2433 }
2434 }
2435
2436 IMember memberInfo = member as IMember;
2437 if (null != memberInfo)
2438 {
2439 if (!AssertTargetContext(node, memberInfo))
2440 {
2441 Error(node);
2442 return;
2443 }
2444
2445 if (EntityType.Method != memberInfo.EntityType)
2446 {
2447 BindExpressionType(node, GetInferredType(memberInfo));
2448 }
2449 else
2450 {
2451 BindExpressionType(node, memberInfo.Type);
2452 }
2453 }
2454
2455 if (EntityType.Property == member.EntityType)
2456 {
2457 IProperty property = (IProperty)member;
2458 if (IsIndexedProperty(property))
2459 {
2460 if (!AstUtil.IsTargetOfSlicing(node)
2461 && (!property.IsExtension || property.GetParameters().Length > 1))
2462 {
2463 Error(node, CompilerErrorFactory.PropertyRequiresParameters(
2464 AstUtil.GetMemberAnchor(node),
2465 member.FullName));
2466 return;
2467 }
2468 }
2469 if (IsWriteOnlyProperty(property) && !IsBeingAssignedTo(node))
2470 {
2471 Error(node, CompilerErrorFactory.PropertyIsWriteOnly(
2472 AstUtil.GetMemberAnchor(node),
2473 member.FullName));
2474 }
2475 }
2476 else if (EntityType.Event == member.EntityType)
2477 {
2478 if (!AstUtil.IsTargetOfMethodInvocation(node) &&
2479 !AstUtil.IsLhsOfInPlaceAddSubtract(node))
2480 {
2481 if (CurrentType == memberInfo.DeclaringType)
2482 {
2483 InternalEvent ev = (InternalEvent)member;
2484 node.Name = ev.BackingField.Name;
2485 node.Entity = ev.BackingField;
2486 BindExpressionType(node, ev.BackingField.Type);
2487 return;
2488 }
2489 else
2490 {
2491 Error(node,
2492 CompilerErrorFactory.EventIsNotAnExpression(node,
2493 member.FullName));
2494 }
2495 }
2496 }
2497
2498 Bind(node, member);
2499 PostProcessReferenceExpression(node);
2500 }
2501
2502 private bool IsBeingAssignedTo(MemberReferenceExpression node)
2503 {
2504 Node current = node;
2505 Node parent = current.ParentNode;
2506 while (!(parent is BinaryExpression))
2507 {
2508 current = parent;
2509 parent = parent.ParentNode;
2510 if (parent == null || !(parent is Expression)) return false;
2511 }
2512 return ((BinaryExpression)parent).Left == current;
2513 }
2514
2515 private bool IsWriteOnlyProperty(IProperty property)
2516 {
2517 return null == property.GetGetMethod();
2518 }
2519
2520 private IEntity ResolveAmbiguousLValue(Expression sourceNode, Ambiguous candidates, Expression rvalue)
2521 {
2522 if (!candidates.AllEntitiesAre(EntityType.Property)) return null;
2523
2524 IEntity[] entities = candidates.Entities;
2525 IEntity[] getters = GetSetMethods(entities);
2526 ExpressionCollection args = new ExpressionCollection();
2527 args.Add(rvalue);
2528 IEntity found = GetCorrectCallableReference(sourceNode, args, getters);
2529 if (null != found && EntityType.Method == found.EntityType)
2530 {
2531 IProperty property = (IProperty)entities[GetIndex(getters, found)];
2532 BindProperty(sourceNode, property);
2533 return property;
2534 }
2535 return null;
2536 }
2537
2538 private static void BindProperty(Expression expression, IProperty property)
2539 {
2540 expression.Entity = property;
2541 expression.ExpressionType = property.Type;
2542 }
2543
2544 private IEntity ResolveAmbiguousReference(ReferenceExpression node, Ambiguous candidates)
2545 {
2546 if (!AstUtil.IsTargetOfSlicing(node)
2547 && !AstUtil.IsLhsOfAssignment(node))
2548 {
2549 if (candidates.AllEntitiesAre(EntityType.Property))
2550 {
2551 return ResolveAmbiguousPropertyReference(node, candidates, EmptyExpressionCollection);
2552 }
2553 else if (candidates.AllEntitiesAre(EntityType.Method))
2554 {
2555 return ResolveAmbiguousMethodReference(node, candidates, EmptyExpressionCollection);
2556 }
2557 else if (candidates.AllEntitiesAre(EntityType.Type))
2558 {
2559 return ResolveAmbiguousTypeReference(node, candidates);
2560 }
2561 }
2562
2563 return ResolveAmbiguousReferenceByAccessibility(candidates);
2564 }
2565
2566 private IEntity ResolveAmbiguousMethodReference(ReferenceExpression node, Ambiguous candidates, ExpressionCollection args)
2567 {
2568 //BOO-656
2569 if (!AstUtil.IsTargetOfMethodInvocation(node)
2570 && !AstUtil.IsTargetOfSlicing(node)
2571 && !AstUtil.IsLhsOfAssignment(node))
2572 {
2573 return candidates.Entities[0];
2574 }
2575 return candidates;
2576 }
2577
2578 private IEntity ResolveAmbiguousPropertyReference(ReferenceExpression node, Ambiguous candidates, ExpressionCollection args)
2579 {
2580 IEntity[] entities = candidates.Entities;
2581 IEntity[] getters = GetGetMethods(entities);
2582 IEntity found = GetCorrectCallableReference(node, args, getters);
2583 if (null != found && EntityType.Method == found.EntityType)
2584 {
2585 IProperty property = (IProperty)entities[GetIndex(getters, found)];
2586 BindProperty(node, property);
2587 return property;
2588 }
2589 return candidates;
2590 }
2591
2592 private IEntity ResolveAmbiguousTypeReference(ReferenceExpression node, Ambiguous candidates)
2593 {
2594 bool isGenericReference = (node.ParentNode is GenericReferenceExpression);
2595
2596 List matches = new List();
2597
2598 foreach (IEntity candidate in candidates.Entities)
2599 {
2600 IType type = candidate as IType;
2601 bool isGenericType = (type != null && type.GenericInfo != null);
2602 if (isGenericType == isGenericReference)
2603 {
2604 matches.Add(candidate);
2605 }
2606 }
2607
2608 if (matches.Count == 1)
2609 {
2610 Bind(node, (IEntity)matches[0]);
2611 }
2612 else
2613 {
2614 Bind(node, new Ambiguous(matches));
2615 }
2616
2617 return node.Entity;
2618 }
2619
2620 private IEntity ResolveAmbiguousReferenceByAccessibility(Ambiguous candidates)
2621 {
2622 List newEntities = new List();
2623 foreach (IEntity entity in candidates.Entities)
2624 {
2625 if (!IsInaccessible(entity))
2626 { newEntities.Add(entity); }
2627 }
2628
2629 if (newEntities.Count == 1)
2630 { return (IEntity)newEntities[0]; }
2631
2632 return new Ambiguous(newEntities);
2633 }
2634
2635 private int GetIndex(IEntity[] entities, IEntity entity)
2636 {
2637 for (int i=0; i<entities.Length; ++i)
2638 {
2639 if (entities[i] == entity) return i;
2640 }
2641 throw new ArgumentException("entity");
2642 }
2643
2644 override public void LeaveUnlessStatement(UnlessStatement node)
2645 {
2646 node.Condition = AssertBoolContext(node.Condition);
2647 }
2648
2649 override public void LeaveIfStatement(IfStatement node)
2650 {
2651 node.Condition = AssertBoolContext(node.Condition);
2652 }
2653
2654 override public void LeaveConditionalExpression(ConditionalExpression node)
2655 {
2656 node.Condition = AssertBoolContext(node.Condition);
2657
2658 IType trueType = GetExpressionType(node.TrueValue);
2659 IType falseType = GetExpressionType(node.FalseValue);
2660
2661 BindExpressionType(node, GetMostGenericType(trueType, falseType));
2662 }
2663
2664 override public bool EnterWhileStatement(WhileStatement node)
2665 {
2666 return true;
2667 }
2668
2669 override public void LeaveWhileStatement(WhileStatement node)
2670 {
2671 node.Condition = AssertBoolContext(node.Condition);
2672 }
2673
2674 override public void LeaveYieldStatement(YieldStatement node)
2675 {
2676 if (EntityType.Constructor == _currentMethod.EntityType)
2677 {
2678 Error(CompilerErrorFactory.YieldInsideConstructor(node));
2679 }
2680 else
2681 {
2682 _currentMethod.AddYieldStatement(node);
2683 }
2684 }
2685
2686 override public void LeaveReturnStatement(ReturnStatement node)
2687 {
2688 if (null == node.Expression) return;
2689
2690 // forces anonymous types to be correctly
2691 // instantiated
2692 IType expressionType = GetConcreteExpressionType(node.Expression);
2693 if (TypeSystemServices.VoidType == expressionType
2694 && node.ContainsAnnotation(OptionalReturnStatementAnnotation))
2695 {
2696 node.ParentNode.Replace(
2697 node,
2698 new ExpressionStatement(node.Expression));
2699 return;
2700 }
2701
2702 IType returnType = _currentMethod.ReturnType;
2703 if (TypeSystemServices.IsUnknown(returnType))
2704 {
2705 _currentMethod.AddReturnExpression(node.Expression);
2706 }
2707 else
2708 {
2709 AssertTypeCompatibility(node.Expression, returnType, expressionType);
2710 }
2711 }
2712
2713 protected Expression GetCorrectIterator(Expression iterator)
2714 {
2715 IType type = GetExpressionType(iterator);
2716 if (TypeSystemServices.IsError(type))
2717 {
2718 return iterator;
2719 }
2720
2721 if (!TypeSystemServices.IEnumerableType.IsAssignableFrom(type) &&
2722 !TypeSystemServices.IEnumeratorType.IsAssignableFrom(type))
2723 {
2724 if (IsRuntimeIterator(type))
2725 {
2726 if (IsTextReader(type))
2727 {
2728 return CodeBuilder.CreateMethodInvocation(TextReaderEnumerator_lines, iterator);
2729 }
2730 else
2731 {
2732 return CodeBuilder.CreateMethodInvocation(RuntimeServices_GetEnumerable, iterator);
2733 }
2734 }
2735 else
2736 {
2737 IMethod method = ResolveGetEnumerator(iterator, type);
2738 if (null == method)
2739 {
2740 Error(CompilerErrorFactory.InvalidIteratorType(iterator, type.ToString()));
2741 }
2742 else
2743 {
2744 return CodeBuilder.CreateMethodInvocation(iterator, method);
2745 }
2746 }
2747 }
2748 return iterator;
2749 }
2750
2751 IMethod ResolveGetEnumerator(Node sourceNode, IType type)
2752 {
2753 IMethod method = ResolveMethod(type, "GetEnumerator");
2754 if (null != method)
2755 {
2756 EnsureRelatedNodeWasVisited(sourceNode, method);
2757 if (0 == method.GetParameters().Length &&
2758 method.ReturnType.IsSubclassOf(TypeSystemServices.IEnumeratorType))
2759 {
2760 return method;
2761 }
2762 }
2763 return null;
2764 }
2765
2766 /// <summary>
2767 /// Process a iterator and its declarations and returns a new iterator
2768 /// expression if necessary.
2769 /// </summary>
2770 protected Expression ProcessIterator(Expression iterator, DeclarationCollection declarations)
2771 {
2772 iterator = GetCorrectIterator(iterator);
2773 ProcessDeclarationsForIterator(declarations, GetExpressionType(iterator));
2774 return iterator;
2775 }
2776
2777 public override void OnGotoStatement(GotoStatement node)
2778 {
2779 // don't try to resolve label references
2780 }
2781
2782 override public void OnForStatement(ForStatement node)
2783 {
2784 Visit(node.Iterator);
2785 node.Iterator = ProcessIterator(node.Iterator, node.Declarations);
2786 VisitForStatementBlock(node);
2787 }
2788
2789 protected void VisitForStatementBlock(ForStatement node)
2790 {
2791 EnterForNamespace(node);
2792 Visit(node.Block);
2793 Visit(node.OrBlock);
2794 Visit(node.ThenBlock);
2795 LeaveNamespace();
2796 }
2797
2798 private void EnterForNamespace(ForStatement node)
2799 {
2800 EnterNamespace(new DeclarationsNamespace(CurrentNamespace, TypeSystemServices, node.Declarations));
2801 }
2802
2803 override public void OnUnpackStatement(UnpackStatement node)
2804 {
2805 Visit(node.Expression);
2806
2807 node.Expression = GetCorrectIterator(node.Expression);
2808
2809 IType defaultDeclarationType = GetEnumeratorItemType(GetExpressionType(node.Expression));
2810 foreach (Declaration d in node.Declarations)
2811 {
2812 bool declareNewVariable = d.Type != null;
2813
2814 GetDeclarationType(defaultDeclarationType, d);
2815 if (declareNewVariable)
2816 {
2817 AssertUniqueLocal(d);
2818 }
2819 else
2820 {
2821 IEntity tag = NameResolutionService.Resolve(d.Name);
2822 if (null != tag)
2823 {
2824 Bind(d, tag);
2825 AssertLValue(d);
2826 continue;
2827 }
2828 }
2829 DeclareLocal(d, false);
2830 }
2831 }
2832
2833 override public void LeaveRaiseStatement(RaiseStatement node)
2834 {
2835 if (node.Exception == null) return;
2836
2837 IType exceptionType = GetExpressionType(node.Exception);
2838 if (TypeSystemServices.StringType == exceptionType)
2839 {
2840 node.Exception = CodeBuilder.CreateConstructorInvocation(
2841 node.Exception.LexicalInfo,
2842 Exception_StringConstructor,
2843 node.Exception);
2844 }
2845 else if (!TypeSystemServices.ExceptionType.IsAssignableFrom(exceptionType))
2846 {
2847 Error(CompilerErrorFactory.InvalidRaiseArgument(node.Exception,
2848 exceptionType.ToString()));
2849 }
2850 }
2851
2852 override public void OnExceptionHandler(ExceptionHandler node)
2853 {
2854 bool untypedException = (node.Flags & ExceptionHandlerFlags.Untyped) == ExceptionHandlerFlags.Untyped;
2855 bool anonymousException = (node.Flags & ExceptionHandlerFlags.Anonymous) == ExceptionHandlerFlags.Anonymous;
2856 bool filterHandler = (node.Flags & ExceptionHandlerFlags.Filter) == ExceptionHandlerFlags.Filter;
2857
2858 if (untypedException)
2859 {
2860 // If untyped, set the handler to except System.Exception
2861 node.Declaration.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.ExceptionType);
2862 }
2863 else
2864 {
2865 Visit(node.Declaration.Type);
2866
2867 // Require typed exception handlers to except only
2868 // exceptions at least as derived as System.Exception
2869 if(!TypeSystemServices.ExceptionType.IsAssignableFrom(GetType(node.Declaration.Type)))
2870 {
2871 Errors.Add(CompilerErrorFactory.InvalidExceptArgument(node.Declaration.Type, GetType(node.Declaration.Type).FullName));
2872 }
2873 }
2874
2875 if(!anonymousException)
2876 {
2877 // If the exception is not anonymous, place it into a
2878 // local variable and enter a new namespace
2879 node.Declaration.Entity = DeclareLocal(node.Declaration, node.Declaration.Name, GetType(node.Declaration.Type), true);
2880 EnterNamespace(new DeclarationsNamespace(CurrentNamespace, TypeSystemServices, node.Declaration));
2881 }
2882
2883 try
2884 {
2885 // The filter handler has access to the exception if it
2886 // is not anonymous, so it is protected to ensure
2887 // any exception in the filter condition (a big no-no)
2888 // will still clean up the namespace if necessary
2889 if (filterHandler)
2890 {
2891 Visit(node.FilterCondition);
2892 }
2893
2894 Visit(node.Block);
2895 }
2896 finally
2897 {
2898 // Clean up the namespace if necessary
2899 if(!anonymousException)
2900 {
2901 LeaveNamespace();
2902 }
2903 }
2904 }
2905
2906 protected virtual bool IsValidIncrementDecrementOperand(Expression e)
2907 {
2908 IType type = GetExpressionType(e);
2909 return IsNumber(type) || TypeSystemServices.IsDuckType(type);
2910 }
2911
2912 void LeaveIncrementDecrement(UnaryExpression node)
2913 {
2914 if (AssertLValue(node.Operand))
2915 {
2916 if (!IsValidIncrementDecrementOperand(node.Operand))
2917 {
2918 InvalidOperatorForType(node);
2919 }
2920 else
2921 {
2922 ExpandIncrementDecrement(node);
2923 }
2924 }
2925 else
2926 {
2927 Error(node);
2928 }
2929 }
2930
2931 void ExpandIncrementDecrement(UnaryExpression node)
2932 {
2933 Node expansion = null;
2934 if (IsArraySlicing(node.Operand))
2935 {
2936 expansion = ExpandIncrementDecrementArraySlicing(node);
2937 }
2938 else
2939 {
2940 expansion = ExpandSimpleIncrementDecrement(node);
2941 }
2942 node.ParentNode.Replace(node, expansion);
2943 Visit(expansion);
2944 }
2945
2946 Expression ExpandIncrementDecrementArraySlicing(UnaryExpression node)
2947 {
2948 SlicingExpression slicing = (SlicingExpression)node.Operand;
2949 CheckNoComplexSlicing(slicing);
2950 Visit(slicing);
2951 return CreateSideEffectAwareSlicingOperation(
2952 node.LexicalInfo,
2953 GetEquivalentBinaryOperator(node.Operator),
2954 slicing,
2955 CodeBuilder.CreateIntegerLiteral(1),
2956 DeclareOldValueTempIfNeeded(node));
2957 }
2958
2959 private Expression CreateSideEffectAwareSlicingOperation(LexicalInfo lexicalInfo, BinaryOperatorType binaryOperator, SlicingExpression lvalue, Expression rvalue, InternalLocal returnValue)
2960 {
2961 MethodInvocationExpression eval = CodeBuilder.CreateEvalInvocation(lexicalInfo);
2962 if (HasSideEffect(lvalue.Target))
2963 {
2964 InternalLocal temp = AddInitializedTempLocal(eval, lvalue.Target);
2965 lvalue.Target = CodeBuilder.CreateReference(temp);
2966 }
2967
2968 foreach (Slice slice in lvalue.Indices)
2969 {
2970 Expression index = slice.Begin;
2971 if (HasSideEffect(index))
2972 {
2973 InternalLocal temp = AddInitializedTempLocal(eval, index);
2974 slice.Begin = CodeBuilder.CreateReference(temp);
2975 }
2976 }
2977
2978 BinaryExpression addition = CodeBuilder.CreateBoundBinaryExpression(
2979 GetExpressionType(lvalue),
2980 binaryOperator,
2981 CloneOrAssignToTemp(returnValue, lvalue),
2982 rvalue);
2983 Expression expansion = CodeBuilder.CreateAssignment(
2984 lvalue.CloneNode(),
2985 addition);
2986 // Resolve operator overloads if any
2987 BindArithmeticOperator(addition);
2988 if (eval.Arguments.Count > 0 || null != returnValue)
2989 {
2990 eval.Arguments.Add(expansion);
2991 if (null != returnValue)
2992 {
2993 eval.Arguments.Add(CodeBuilder.CreateReference(returnValue));
2994 }
2995 BindExpressionType(eval, GetExpressionType(lvalue));
2996 expansion = eval;
2997 }
2998 return expansion;
2999 }
3000
3001 InternalLocal AddInitializedTempLocal(MethodInvocationExpression eval, Expression initializer)
3002 {
3003 InternalLocal temp = DeclareTempLocal(GetExpressionType(initializer));
3004 eval.Arguments.Add(
3005 CodeBuilder.CreateAssignment(
3006 CodeBuilder.CreateReference(temp),
3007 initializer));
3008 return temp;
3009 }
3010
3011 InternalLocal DeclareOldValueTempIfNeeded(UnaryExpression node)
3012 {
3013 return AstUtil.IsPostUnaryOperator(node.Operator)
3014 ? DeclareTempLocal(GetExpressionType(node.Operand))
3015 : null;
3016 }
3017
3018 Expression ExpandSimpleIncrementDecrement(UnaryExpression node)
3019 {
3020 InternalLocal oldValue = DeclareOldValueTempIfNeeded(node);
3021
3022 BinaryExpression addition = CodeBuilder.CreateBoundBinaryExpression(
3023 GetExpressionType(node.Operand),
3024 GetEquivalentBinaryOperator(node.Operator),
3025 CloneOrAssignToTemp(oldValue, node.Operand),
3026 CodeBuilder.CreateIntegerLiteral(1));
3027
3028 BinaryExpression assign = CodeBuilder.CreateAssignment(
3029 node.LexicalInfo,
3030 node.Operand,
3031 addition);
3032
3033 // Resolve operator overloads if any
3034 BindArithmeticOperator(addition);
3035
3036 return null == oldValue
3037 ? (Expression) assign
3038 : CodeBuilder.CreateEvalInvocation(
3039 node.LexicalInfo,
3040 assign,
3041 CodeBuilder.CreateReference(oldValue));
3042 }
3043
3044 Expression CloneOrAssignToTemp(InternalLocal temp, Expression operand)
3045 {
3046 return null == temp
3047 ? operand.CloneNode()
3048 : CodeBuilder.CreateAssignment(
3049 CodeBuilder.CreateReference(temp),
3050 operand.CloneNode());
3051 }
3052
3053 BinaryOperatorType GetEquivalentBinaryOperator(UnaryOperatorType op)
3054 {
3055 return op == UnaryOperatorType.Increment || op == UnaryOperatorType.PostIncrement
3056 ? BinaryOperatorType.Addition
3057 : BinaryOperatorType.Subtraction;
3058 }
3059
3060 UnaryOperatorType GetRelatedPreOperator(UnaryOperatorType op)
3061 {
3062 switch (op)
3063 {
3064 case UnaryOperatorType.PostIncrement:
3065 {
3066 return UnaryOperatorType.Increment;
3067 }
3068 case UnaryOperatorType.PostDecrement:
3069 {
3070 return UnaryOperatorType.Decrement;
3071 }
3072 }
3073 throw new ArgumentException("op");
3074 }
3075
3076 override public bool EnterUnaryExpression(UnaryExpression node)
3077 {
3078 if (AstUtil.IsPostUnaryOperator(node.Operator))
3079 {
3080 if (NodeType.ExpressionStatement == node.ParentNode.NodeType)
3081 {
3082 // nothing to do, a post operator inside a statement
3083 // behaves just like its equivalent pre operator
3084 node.Operator = GetRelatedPreOperator(node.Operator);
3085 }
3086 }
3087 return true;
3088 }
3089
3090 override public void LeaveUnaryExpression(UnaryExpression node)
3091 {
3092 switch (node.Operator)
3093 {
3094 case UnaryOperatorType.Explode:
3095 {
3096 LeaveExplodeExpression(node);
3097 break;
3098 }
3099 case UnaryOperatorType.LogicalNot:
3100 {
3101 LeaveLogicalNot(node);
3102 break;
3103 }
3104
3105 case UnaryOperatorType.Increment:
3106 case UnaryOperatorType.PostIncrement:
3107 case UnaryOperatorType.Decrement:
3108 case UnaryOperatorType.PostDecrement:
3109 {
3110 LeaveIncrementDecrement(node);
3111 break;
3112 }
3113
3114 case UnaryOperatorType.UnaryNegation:
3115 {
3116 LeaveUnaryNegation(node);
3117 break;
3118 }
3119
3120 case UnaryOperatorType.OnesComplement:
3121 {
3122 LeaveOnesComplement(node);
3123 break;
3124 }
3125
3126 default:
3127 {
3128 NotImplemented(node, "unary operator not supported");
3129 break;
3130 }
3131 }
3132 }
3133
3134 private void LeaveOnesComplement(UnaryExpression node)
3135 {
3136 if (IsPrimitiveOnesComplementOperand(node.Operand))
3137 {
3138 BindExpressionType(node, GetExpressionType(node.Operand));
3139 }
3140 else
3141 {
3142 ProcessOperatorOverload(node);
3143 }
3144 }
3145
3146 private bool IsPrimitiveOnesComplementOperand(Expression operand)
3147 {
3148 IType type = GetExpressionType(operand);
3149 return TypeSystemServices.IsIntegerNumber(type) || type.IsEnum;
3150 }
3151
3152 private void LeaveLogicalNot(UnaryExpression node)
3153 {
3154 node.Operand = AssertBoolContext(node.Operand);
3155 BindExpressionType(node, TypeSystemServices.BoolType);
3156 }
3157
3158 private void LeaveUnaryNegation(UnaryExpression node)
3159 {
3160 if (IsPrimitiveNumber(node.Operand))
3161 {
3162 BindExpressionType(node, GetExpressionType(node.Operand));
3163 }
3164 else
3165 {
3166 ProcessOperatorOverload(node);
3167 }
3168 }
3169
3170 private void ProcessOperatorOverload(UnaryExpression node)
3171 {
3172 if (! ResolveOperator(node))
3173 {
3174 InvalidOperatorForType(node);
3175 }
3176 }
3177
3178 override public bool EnterBinaryExpression(BinaryExpression node)
3179 {
3180 if (BinaryOperatorType.Assign == node.Operator)
3181 {
3182 if (NodeType.ReferenceExpression == node.Left.NodeType &&
3183 null == node.Left.Entity)
3184 {
3185 // Auto local declaration:
3186 // assign to unknown reference implies local
3187 // declaration
3188 ReferenceExpression reference = (ReferenceExpression)node.Left;
3189 IEntity info = NameResolutionService.Resolve(reference.Name);
3190 if (null == info || TypeSystemServices.IsBuiltin(info) || IsInaccessible(info))
3191 {
3192 Visit(node.Right);
3193 IType expressionType = MapNullToObject(GetConcreteExpressionType(node.Right));
3194 IEntity local = DeclareLocal(reference, reference.Name, expressionType);
3195 reference.Entity = local;
3196 BindExpressionType(node.Left, expressionType);
3197 BindExpressionType(node, expressionType);
3198 return false;
3199 }
3200 }
3201 }
3202 return true;
3203 }
3204
3205 bool IsInaccessible(IEntity info)
3206 {
3207 IAccessibleMember accessible = info as IAccessibleMember;
3208 if (accessible != null && accessible.IsPrivate
3209 && accessible.DeclaringType != CurrentType)
3210 {
3211 return true;
3212 }
3213 return false;
3214 }
3215
3216 override public void LeaveBinaryExpression(BinaryExpression node)
3217 {
3218 if (TypeSystemServices.IsUnknown(node.Left) ||
3219 TypeSystemServices.IsUnknown(node.Right))
3220 {
3221 BindExpressionType(node, Unknown.Default);
3222 return;
3223 }
3224
3225 if (TypeSystemServices.IsError(node.Left)
3226 || TypeSystemServices.IsError(node.Right))
3227 {
3228 Error(node);
3229 return;
3230 }
3231 BindBinaryExpression(node);
3232 }
3233
3234 protected virtual void BindBinaryExpression(BinaryExpression node)
3235 {
3236 if (IsEnumOperation(node))
3237 {
3238 BindEnumOperation(node);
3239 return;
3240 }
3241
3242 switch (node.Operator)
3243 {
3244 case BinaryOperatorType.Assign:
3245 {
3246 BindAssignment(node);
3247 break;
3248 }
3249
3250 case BinaryOperatorType.Addition:
3251 {
3252 if (GetExpressionType(node.Left).IsArray &&
3253 GetExpressionType(node.Right).IsArray)
3254 {
3255 BindArrayAddition(node);
3256 }
3257 else
3258 {
3259 BindArithmeticOperator(node);
3260 }
3261 break;
3262 }
3263
3264 case BinaryOperatorType.Subtraction:
3265 case BinaryOperatorType.Multiply:
3266 case BinaryOperatorType.Division:
3267 case BinaryOperatorType.Modulus:
3268 case BinaryOperatorType.Exponentiation:
3269 {
3270 BindArithmeticOperator(node);
3271 break;
3272 }
3273
3274 case BinaryOperatorType.TypeTest:
3275 {
3276 BindTypeTest(node);
3277 break;
3278 }
3279
3280 case BinaryOperatorType.ReferenceEquality:
3281 {
3282 BindReferenceEquality(node);
3283 break;
3284 }
3285
3286 case BinaryOperatorType.ReferenceInequality:
3287 {
3288 BindReferenceEquality(node);
3289 break;
3290 }
3291
3292 case BinaryOperatorType.Or:
3293 case BinaryOperatorType.And:
3294 {
3295 BindLogicalOperator(node);
3296 break;
3297 }
3298
3299 case BinaryOperatorType.BitwiseAnd:
3300 case BinaryOperatorType.BitwiseOr:
3301 case BinaryOperatorType.ExclusiveOr:
3302 case BinaryOperatorType.ShiftLeft:
3303 case BinaryOperatorType.ShiftRight:
3304 {
3305 BindBitwiseOperator(node);
3306 break;
3307 }
3308
3309 case BinaryOperatorType.InPlaceSubtraction:
3310 case BinaryOperatorType.InPlaceAddition:
3311 {
3312 BindInPlaceAddSubtract(node);
3313 break;
3314 }
3315
3316 case BinaryOperatorType.InPlaceShiftLeft:
3317 case BinaryOperatorType.InPlaceShiftRight:
3318 case BinaryOperatorType.InPlaceDivision:
3319 case BinaryOperatorType.InPlaceMultiply:
3320 case BinaryOperatorType.InPlaceBitwiseOr:
3321 case BinaryOperatorType.InPlaceBitwiseAnd:
3322 case BinaryOperatorType.InPlaceExclusiveOr:
3323 {
3324 BindInPlaceArithmeticOperator(node);
3325 break;
3326 }
3327
3328 case BinaryOperatorType.GreaterThan:
3329 case BinaryOperatorType.GreaterThanOrEqual:
3330 case BinaryOperatorType.LessThan:
3331 case BinaryOperatorType.LessThanOrEqual:
3332 case BinaryOperatorType.Inequality:
3333 case BinaryOperatorType.Equality:
3334 {
3335 BindCmpOperator(node);
3336 break;
3337 }
3338
3339 default:
3340 {
3341 if (!ResolveOperator(node))
3342 {
3343 InvalidOperatorForTypes(node);
3344 }
3345 break;
3346 }
3347 }
3348 }
3349
3350 IType GetMostGenericType(BinaryExpression node)
3351 {
3352 return GetMostGenericType(
3353 GetExpressionType(node.Left),
3354 GetExpressionType(node.Right));
3355 }
3356
3357 bool IsNullableOperation(BinaryExpression node)
3358 {
3359 if (null == node.Left.ExpressionType || null == node.Right.ExpressionType)
3360 {
3361 return false;
3362 }
3363
3364 return TypeSystemServices.IsNullable(GetExpressionType(node.Left))
3365 || TypeSystemServices.IsNullable(GetExpressionType(node.Right));
3366 }
3367
3368 bool IsEnumOperation(BinaryExpression node)
3369 {
3370 switch (node.Operator)
3371 {
3372 case BinaryOperatorType.Addition:
3373 case BinaryOperatorType.Subtraction:
3374 case BinaryOperatorType.BitwiseAnd:
3375 case BinaryOperatorType.BitwiseOr:
3376 case BinaryOperatorType.ExclusiveOr:
3377 IType lhs = GetExpressionType(node.Left);
3378 IType rhs = GetExpressionType(node.Right);
3379 if (lhs.IsEnum) return IsValidEnumOperand(lhs, rhs);
3380 if (rhs.IsEnum) return IsValidEnumOperand(rhs, lhs);
3381 break;
3382 }
3383 return false;
3384 }
3385
3386 bool IsValidEnumOperand(IType expected, IType actual)
3387 {
3388 if (expected == actual) return true;
3389 if (actual.IsEnum) return true;
3390 return TypeSystemServices.IsIntegerNumber(actual);
3391 }
3392
3393 void BindEnumOperation(BinaryExpression node)
3394 {
3395 IType lhs = GetExpressionType(node.Left);
3396 IType rhs = GetExpressionType(node.Right);
3397 switch(node.Operator)
3398 {
3399 case BinaryOperatorType.Addition:
3400 if (lhs.IsEnum != rhs.IsEnum)
3401 {
3402 BindExpressionType(node, lhs.IsEnum ? lhs : rhs);
3403 return;
3404 }
3405 break;
3406 case BinaryOperatorType.Subtraction:
3407 if (lhs == rhs)
3408 {
3409 BindExpressionType(node, TypeSystemServices.IntType);
3410 return;
3411 }
3412 else if (lhs.IsEnum && !rhs.IsEnum)
3413 {
3414 BindExpressionType(node, lhs);
3415 return;
3416 }
3417 break;
3418 case BinaryOperatorType.BitwiseAnd:
3419 case BinaryOperatorType.BitwiseOr:
3420 case BinaryOperatorType.ExclusiveOr:
3421 if (lhs == rhs)
3422 {
3423 BindExpressionType(node, lhs);
3424 return;
3425 }
3426 break;
3427 }
3428 if (!ResolveOperator(node))
3429 {
3430 InvalidOperatorForTypes(node);
3431 }
3432 }
3433
3434 void BindBitwiseOperator(BinaryExpression node)
3435 {
3436 IType lhs = GetExpressionType(node.Left);
3437 IType rhs = GetExpressionType(node.Right);
3438
3439 if (TypeSystemServices.IsIntegerOrBool(lhs) &&
3440 TypeSystemServices.IsIntegerOrBool(rhs))
3441 {
3442 BindExpressionType(node, TypeSystemServices.GetPromotedNumberType(lhs, rhs));
3443 }
3444 else
3445 {
3446 // if (lhs.IsEnum && rhs == lhs)
3447 // {
3448 // BindExpressionType(node, lhs);
3449 // }
3450 // else
3451 // {
3452 if (!ResolveOperator(node))
3453 {
3454 InvalidOperatorForTypes(node);
3455 }
3456 // }
3457 }
3458 }
3459
3460 bool IsChar(IType type)
3461 {
3462 return TypeSystemServices.CharType == type;
3463 }
3464
3465 void BindCmpOperator(BinaryExpression node)
3466 {
3467 if (BindNullableOperation(node))
3468 {
3469 return;
3470 }
3471
3472 IType lhs = GetExpressionType(node.Left);
3473 IType rhs = GetExpressionType(node.Right);
3474
3475 if (IsPrimitiveComparison(lhs, rhs))
3476 {
3477 BindExpressionType(node, TypeSystemServices.BoolType);
3478 return;
3479 }
3480
3481 if (lhs.IsEnum || rhs.IsEnum)
3482 {
3483 if (lhs == rhs || IsPrimitiveNumber(rhs) || IsPrimitiveNumber(lhs))
3484 {
3485 BindExpressionType(node, TypeSystemServices.BoolType);
3486 }
3487 else
3488 {
3489 if (!ResolveOperator(node))
3490 {
3491 InvalidOperatorForTypes(node);
3492 }
3493 }
3494 return;
3495 }
3496
3497 if (!ResolveOperator(node))
3498 {
3499 switch (node.Operator)
3500 {
3501 case BinaryOperatorType.Equality:
3502 {
3503 if (OptimizeNullComparisons
3504 && (IsNull(node.Left) || IsNull(node.Right)))
3505 {
3506 node.Operator = BinaryOperatorType.ReferenceEquality;
3507 BindReferenceEquality(node);
3508 break;
3509 }
3510 Expression expression = CreateEquals(node);
3511 node.ParentNode.Replace(node, expression);
3512 break;
3513 }
3514
3515 case BinaryOperatorType.Inequality:
3516 {
3517 if (OptimizeNullComparisons
3518 && (IsNull(node.Left) || IsNull(node.Right)))
3519 {
3520 node.Operator = BinaryOperatorType.ReferenceInequality;
3521 BindReferenceEquality(node);
3522 break;
3523 }
3524 Expression expression = CreateEquals(node);
3525 Node parent = node.ParentNode;
3526 parent.Replace(node, CodeBuilder.CreateNotExpression(expression));
3527 break;
3528 }
3529
3530 default:
3531 {
3532 InvalidOperatorForTypes(node);
3533 break;
3534 }
3535 }
3536 }
3537 }
3538
3539 private bool IsPrimitiveComparison(IType lhs, IType rhs)
3540 {
3541 if (IsPrimitiveNumberOrChar(lhs) && IsPrimitiveNumberOrChar(rhs)) return true;
3542 if (IsBool(lhs) && IsBool(rhs)) return true;
3543 return false;
3544 }
3545
3546 private bool IsPrimitiveNumberOrChar(IType lhs)
3547 {
3548 return IsPrimitiveNumber(lhs) || IsChar(lhs);
3549 }
3550
3551 private bool IsBool(IType lhs)
3552 {
3553 return TypeSystemServices.BoolType == lhs;
3554 }
3555
3556 static bool IsNull(Expression node)
3557 {
3558 return NodeType.NullLiteralExpression == node.NodeType;
3559 }
3560
3561 void BindLogicalOperator(BinaryExpression node)
3562 {
3563 node.Left = AssertBoolContext(node.Left);
3564 node.Right = AssertBoolContext(node.Right);
3565 BindExpressionType(node, GetMostGenericType(node));
3566 }
3567
3568 void BindInPlaceAddSubtract(BinaryExpression node)
3569 {
3570 IEntity entity = node.Left.Entity;
3571 if (null != entity &&
3572 (EntityType.Event == entity.EntityType
3573 || EntityType.Ambiguous == entity.EntityType))
3574 {
3575 BindEventSubscription(node);
3576 }
3577 else
3578 {
3579 BindInPlaceArithmeticOperator(node);
3580 }
3581 }
3582
3583 void BindEventSubscription(BinaryExpression node)
3584 {
3585 IEntity tag = GetEntity(node.Left);
3586 if (EntityType.Event != tag.EntityType)
3587 {
3588 if (EntityType.Ambiguous == tag.EntityType)
3589 {
3590 IList found = ((Ambiguous)tag).Select(IsPublicEvent);
3591 if (found.Count != 1)
3592 {
3593 tag = null;
3594 }
3595 else
3596 {
3597 tag = (IEntity)found[0];
3598 Bind(node.Left, tag);
3599 }
3600 }
3601 }
3602
3603 IEvent eventInfo = (IEvent)tag;
3604 IType rtype = GetExpressionType(node.Right);
3605 if (!AssertDelegateArgument(node, eventInfo, rtype))
3606 {
3607 Error(node);
3608 return;
3609 }
3610
3611 IMethod method = null;
3612 if (node.Operator == BinaryOperatorType.InPlaceAddition)
3613 {
3614 method = eventInfo.GetAddMethod();
3615 }
3616 else
3617 {
3618 method = eventInfo.GetRemoveMethod();
3619 CallableSignature expected = GetCallableSignature(eventInfo.Type);
3620 CallableSignature actual = GetCallableSignature(node.Right);
3621 if (expected != actual)
3622 {
3623 Warnings.Add(
3624 CompilerWarningFactory.InvalidEventUnsubscribe(
3625 node,
3626 eventInfo.FullName,
3627 expected));
3628 }
3629 }
3630
3631 MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
3632 ((MemberReferenceExpression)node.Left).Target,
3633 method,
3634 node.Right);
3635 node.ParentNode.Replace(node, mie);
3636 }
3637
3638 CallableSignature GetCallableSignature(Expression node)
3639 {
3640 return GetCallableSignature(GetExpressionType(node));
3641 }
3642
3643 CallableSignature GetCallableSignature(IType type)
3644 {
3645 return ((ICallableType)type).GetSignature();
3646 }
3647
3648 virtual protected void ProcessBuiltinInvocation(BuiltinFunction function, MethodInvocationExpression node)
3649 {
3650 switch (function.FunctionType)
3651 {
3652 case BuiltinFunctionType.Len:
3653 {
3654 ProcessLenInvocation(node);
3655 break;
3656 }
3657
3658 case BuiltinFunctionType.AddressOf:
3659 {
3660 ProcessAddressOfInvocation(node);
3661 break;
3662 }
3663
3664 case BuiltinFunctionType.Eval:
3665 {
3666 ProcessEvalInvocation(node);
3667 break;
3668 }
3669
3670 default:
3671 {
3672 NotImplemented(node, "BuiltinFunction: " + function);
3673 break;
3674 }
3675 }
3676 }
3677
3678 bool ProcessSwitchInvocation(MethodInvocationExpression node)
3679 {
3680 if (BuiltinFunction.Switch != node.Target.Entity) return false;
3681 BindSwitchLabelReferences(node);
3682 if (CheckSwitchArguments(node)) return true;
3683 Error(node, CompilerErrorFactory.InvalidSwitch(node.Target));
3684 return true;
3685 }
3686
3687 private static void BindSwitchLabelReferences(MethodInvocationExpression node)
3688 {
3689 for (int i = 1; i < node.Arguments.Count; ++i)
3690 {
3691 ReferenceExpression label = (ReferenceExpression)node.Arguments[i];
3692 label.ExpressionType = Unknown.Default;
3693 }
3694 }
3695
3696 bool CheckSwitchArguments(MethodInvocationExpression node)
3697 {
3698 ExpressionCollection args = node.Arguments;
3699 if (args.Count > 1)
3700 {
3701 Visit(args[0]);
3702 if (TypeSystemServices.IsIntegerNumber(GetExpressionType(args[0])))
3703 {
3704 for (int i=1; i<args.Count; ++i)
3705 {
3706 if (NodeType.ReferenceExpression != args[i].NodeType)
3707 {
3708 return false;
3709 }
3710 }
3711 return true;
3712 }
3713 }
3714 return false;
3715 }
3716
3717 void ProcessEvalInvocation(MethodInvocationExpression node)
3718 {
3719 if (node.Arguments.Count > 0)
3720 {
3721 int allButLast = node.Arguments.Count-1;
3722 for (int i=0; i<allButLast; ++i)
3723 {
3724 AssertHasSideEffect(node.Arguments[i]);
3725 }
3726 BindExpressionType(node, GetConcreteExpressionType(node.Arguments[-1]));
3727 }
3728 else
3729 {
3730 BindExpressionType(node, TypeSystemServices.VoidType);
3731 }
3732 }
3733
3734 void ProcessAddressOfInvocation(MethodInvocationExpression node)
3735 {
3736 if (node.Arguments.Count != 1)
3737 {
3738 Error(node, CompilerErrorFactory.MethodArgumentCount(node.Target, "__addressof__", 1));
3739 }
3740 else
3741 {
3742 Expression arg = node.Arguments[0];
3743
3744 EntityType type = GetEntity(arg).EntityType;
3745
3746 if (EntityType.Method != type)
3747 {
3748 ReferenceExpression reference = arg as ReferenceExpression;
3749 if (null != reference && EntityType.Ambiguous == type)
3750 {
3751 Error(node, CompilerErrorFactory.AmbiguousReference(arg, reference.Name, ((Ambiguous)arg.Entity).Entities));
3752 }
3753 else
3754 {
3755 Error(node, CompilerErrorFactory.MethodReferenceExpected(arg));
3756 }
3757 }
3758 else
3759 {
3760 BindExpressionType(node, TypeSystemServices.IntPtrType);
3761 }
3762 }
3763 }
3764
3765 void ProcessLenInvocation(MethodInvocationExpression node)
3766 {
3767 if ((node.Arguments.Count < 1) || (node.Arguments.Count > 2))
3768 {
3769 Error(node, CompilerErrorFactory.MethodArgumentCount(node.Target, "len", node.Arguments.Count));
3770 return;
3771 }
3772
3773 MethodInvocationExpression resultingNode = null;
3774
3775 Expression target = node.Arguments[0];
3776 IType type = GetExpressionType(target);
3777 bool isArray = TypeSystemServices.ArrayType.IsAssignableFrom(type);
3778
3779 if ((!isArray) && (node.Arguments.Count != 1))
3780 {
3781 Error(node, CompilerErrorFactory.MethodArgumentCount(node.Target, "len", node.Arguments.Count));
3782 }
3783 if (TypeSystemServices.IsSystemObject(type))
3784 {
3785 resultingNode = CodeBuilder.CreateMethodInvocation(RuntimeServices_Len, target);
3786 }
3787 else if (TypeSystemServices.StringType == type)
3788 {
3789 resultingNode = CodeBuilder.CreateMethodInvocation(target, String_get_Length);
3790 }
3791 else if (isArray)
3792 {
3793 if (node.Arguments.Count == 1)
3794 {
3795 resultingNode = CodeBuilder.CreateMethodInvocation(target, Array_get_Length);
3796 }
3797 else
3798 {
3799 resultingNode = CodeBuilder.CreateMethodInvocation(target,
3800 Array_GetLength, node.Arguments[1]);
3801 }
3802 }
3803 else if (TypeSystemServices.ICollectionType.IsAssignableFrom(type))
3804 {
3805 resultingNode = CodeBuilder.CreateMethodInvocation(target, ICollection_get_Count);
3806 }
3807 else
3808 {
3809 Error(CompilerErrorFactory.InvalidLen(target, type.ToString()));
3810 }
3811 if (null != resultingNode)
3812 {
3813 node.ParentNode.Replace(node, resultingNode);
3814 }
3815 }
3816
3817 void CheckListLiteralArgumentInArrayConstructor(IType expectedElementType, MethodInvocationExpression constructor)
3818 {
3819 ListLiteralExpression elements = constructor.Arguments[1] as ListLiteralExpression;
3820 if (null == elements) return;
3821 CheckItems(expectedElementType, elements.Items);
3822 }
3823
3824 private void CheckItems(IType expectedElementType, ExpressionCollection items)
3825 {
3826 foreach (Expression element in items)
3827 {
3828 AssertTypeCompatibility(element, expectedElementType, GetExpressionType(element));
3829 }
3830 }
3831
3832 void ApplyBuiltinMethodTypeInference(MethodInvocationExpression expression, IMethod method)
3833 {
3834 IType inferredType = null;
3835
3836 if (Array_TypedEnumerableConstructor == method ||
3837 Array_TypedCollectionConstructor == method ||
3838 Array_TypedConstructor2 == method)
3839 {
3840 IType type = TypeSystemServices.GetReferencedType(expression.Arguments[0]);
3841 if (null != type)
3842 {
3843 if (Array_TypedCollectionConstructor == method)
3844 {
3845 CheckListLiteralArgumentInArrayConstructor(type, expression);
3846 }
3847 inferredType = TypeSystemServices.GetArrayType(type, 1);
3848 }
3849 }
3850 else if (MultiDimensionalArray_TypedConstructor == method)
3851 {
3852 IType type = TypeSystemServices.GetReferencedType(expression.Arguments[0]);
3853 if (null != type)
3854 {
3855 inferredType = TypeSystemServices.GetArrayType(type, expression.Arguments.Count-1);
3856 }
3857 }
3858 else if (Array_EnumerableConstructor == method)
3859 {
3860 IType enumeratorItemType = GetEnumeratorItemType(GetExpressionType(expression.Arguments[0]));
3861 if (TypeSystemServices.ObjectType != enumeratorItemType)
3862 {
3863 inferredType = TypeSystemServices.GetArrayType(enumeratorItemType, 1);
3864 expression.Target.Entity = Array_TypedEnumerableConstructor;
3865 expression.ExpressionType = Array_TypedEnumerableConstructor.ReturnType;
3866 expression.Arguments.Insert(0, CodeBuilder.CreateReference(enumeratorItemType));
3867 }
3868 }
3869
3870 if (null != inferredType)
3871 {
3872 Node parent = expression.ParentNode;
3873 parent.Replace(expression,
3874 CodeBuilder.CreateCast(inferredType, expression));
3875 }
3876 }
3877
3878 protected virtual IEntity ResolveAmbiguousMethodInvocation(MethodInvocationExpression node, Ambiguous entity)
3879 {
3880 _context.TraceVerbose("{0}: resolving ambigous method invocation: {1}", node.LexicalInfo, entity);
3881
3882 IEntity resolved = ResolveCallableReference(node, entity);
3883 if (null != resolved) return resolved;
3884
3885 if (TryToProcessAsExtensionInvocation(node)) return null;
3886
3887 return CantResolveAmbiguousMethodInvocation(node, entity.Entities);
3888 }
3889
3890 private IEntity ResolveCallableReference(MethodInvocationExpression node, Ambiguous entity)
3891 {
3892 IEntity resolved = _callableResolution.ResolveCallableReference(node.Arguments, entity.Entities);
3893 if (null == resolved) return null;
3894
3895 IMember member = (IMember)resolved;
3896 if (NodeType.ReferenceExpression == node.Target.NodeType)
3897 {
3898 ResolveMemberInfo((ReferenceExpression)node.Target, member);
3899 }
3900 else
3901 {
3902 Bind(node.Target, member);
3903 BindExpressionType(node.Target, member.Type);
3904 }
3905 return resolved;
3906 }
3907
3908 private bool TryToProcessAsExtensionInvocation(MethodInvocationExpression node)
3909 {
3910 IEntity extension = ResolveExtension(node);
3911 if (null == extension) return false;
3912
3913 ProcessExtensionMethodInvocation(node, extension);
3914 return true;
3915 }
3916
3917 private IEntity ResolveExtension(MethodInvocationExpression node)
3918 {
3919 MemberReferenceExpression mre = node.Target as MemberReferenceExpression;
3920 if (mre == null) return null;
3921
3922 return NameResolutionService.ResolveExtension(GetReferenceNamespace(mre), mre.Name);
3923 }
3924
3925 protected virtual IEntity CantResolveAmbiguousMethodInvocation(MethodInvocationExpression node, IEntity[] entities)
3926 {
3927 EmitCallableResolutionError(node, entities, node.Arguments);
3928 Error(node);
3929 return null;
3930 }
3931
3932 override public void OnMethodInvocationExpression(MethodInvocationExpression node)
3933 {
3934 if (null != node.ExpressionType)
3935 {
3936 _context.TraceVerbose("{0}: Method invocation already bound.", node.LexicalInfo);
3937 return;
3938 }
3939
3940 Visit(node.Target);
3941
3942 if (ProcessSwitchInvocation(node)) return;
3943
3944 if (ProcessMetaMethodInvocation(node)) return;
3945
3946 Visit(node.Arguments);
3947
3948 if (TypeSystemServices.IsError(node.Target)
3949 || TypeSystemServices.IsErrorAny(node.Arguments))
3950 {
3951 Error(node);
3952 return;
3953 }
3954
3955 IEntity targetEntity = node.Target.Entity;
3956 if (null == targetEntity)
3957 {
3958 ProcessGenericMethodInvocation(node);
3959 return;
3960 }
3961
3962 if (IsOrContainsBooExtensionMethod(targetEntity))
3963 {
3964 ProcessExtensionMethodInvocation(node, targetEntity);
3965 return;
3966 }
3967
3968 ProcessMethodInvocationExpression(node, targetEntity);
3969 }
3970
3971 private bool ProcessMetaMethodInvocation(MethodInvocationExpression node)
3972 {
3973 IEntity targetEntity = node.Target.Entity;
3974 if (null == targetEntity) return false;
3975 if (!IsOrContainMetaMethod(targetEntity)) return false;
3976
3977 object[] arguments = GetMetaMethodInvocationArguments(node);
3978 Type[] argumentTypes = MethodResolver.GetArgumentTypes(arguments);
3979 MethodResolver resolver = new MethodResolver(argumentTypes);
3980 CandidateMethod method = resolver.ResolveMethod(EnumerateMetaMethods(targetEntity));
3981 if (null == method) return false;
3982
3983 // TODO: cache emitted dispatchers
3984 MethodDispatcherEmitter emitter = new MethodDispatcherEmitter(method, argumentTypes);
3985 Node replacement = (Node)emitter.Emit()(null, arguments);
3986 ReplaceMetaMethodInvocationSite(node, replacement);
3987
3988 return true;
3989 }
3990
3991 private static object[] GetMetaMethodInvocationArguments(MethodInvocationExpression node)
3992 {
3993 if (node.NamedArguments.Count == 0) return node.Arguments.ToArray();
3994
3995 List arguments = new List();
3996 arguments.Add(node.NamedArguments.ToArray());
3997 arguments.Extend(node.Arguments);
3998 return arguments.ToArray();
3999 }
4000
4001 private void ReplaceMetaMethodInvocationSite(MethodInvocationExpression node, Node replacement)
4002 {
4003 if (replacement is Statement)
4004 {
4005 if (node.ParentNode.NodeType != NodeType.ExpressionStatement)
4006 NotImplemented(node, "Cant use an statement where an expression is expected.");
4007 node.ParentNode.ParentNode.Replace(node.ParentNode, replacement);
4008 }
4009 else
4010 {
4011 node.ParentNode.Replace(node, replacement);
4012 }
4013 Visit(replacement);
4014 }
4015
4016 private System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo> EnumerateMetaMethods(IEntity entity)
4017 {
4018 if (entity.EntityType == EntityType.Method)
4019 {
4020 yield return GetMethodInfo(entity);
4021 }
4022 else
4023 {
4024 foreach (IEntity item in ((Ambiguous)entity).Entities)
4025 {
4026 yield return GetMethodInfo(item);
4027 }
4028 }
4029 }
4030
4031 private static MethodInfo GetMethodInfo(IEntity entity)
4032 {
4033 return (MethodInfo)((ExternalMethod) entity).MethodInfo;
4034 }
4035
4036 private bool IsOrContainMetaMethod(IEntity entity)
4037 {
4038 switch (entity.EntityType)
4039 {
4040 case EntityType.Ambiguous:
4041 return ((Ambiguous) entity).Any(IsMetaMethod);
4042 case EntityType.Method:
4043 return IsMetaMethod(entity);
4044 }
4045 return false;
4046 }
4047
4048 private static bool IsMetaMethod(IEntity entity)
4049 {
4050 ExternalMethod m = entity as ExternalMethod;
4051 if (m == null) return false;
4052 return m.IsMeta;
4053 }
4054
4055 private void ProcessMethodInvocationExpression(MethodInvocationExpression node, IEntity targetEntity)
4056 {
4057 switch (targetEntity.EntityType)
4058 {
4059 case EntityType.Ambiguous:
4060 {
4061 ProcessAmbiguousMethodInvocation(node, targetEntity);
4062 break;
4063 }
4064 case EntityType.BuiltinFunction:
4065 {
4066 ProcessBuiltinInvocation((BuiltinFunction)targetEntity, node);
4067 break;
4068 }
4069 case EntityType.Event:
4070 {
4071 ProcessEventInvocation((IEvent)targetEntity, node);
4072 break;
4073 }
4074
4075 case EntityType.Method:
4076 {
4077 ProcessMethodInvocation(node, targetEntity);
4078 break;
4079 }
4080
4081 case EntityType.Constructor:
4082 {
4083 ProcessConstructorInvocation(node, targetEntity);
4084 break;
4085 }
4086
4087 case EntityType.Type:
4088 {
4089 ProcessTypeInvocation(node);
4090 break;
4091 }
4092
4093 case EntityType.Error:
4094 {
4095 Error(node);
4096 break;
4097 }
4098
4099 default:
4100 {
4101 ProcessGenericMethodInvocation(node);
4102 break;
4103 }
4104 }
4105 }
4106
4107 protected virtual void ProcessAmbiguousMethodInvocation(MethodInvocationExpression node, IEntity targetEntity)
4108 {
4109 targetEntity = ResolveAmbiguousMethodInvocation(node, (Ambiguous)targetEntity);
4110 if (null == targetEntity) return;
4111 ProcessMethodInvocationExpression(node, targetEntity);
4112 }
4113
4114 private void ProcessConstructorInvocation(MethodInvocationExpression node, IEntity targetEntity)
4115 {
4116 NamedArgumentsNotAllowed(node);
4117 InternalConstructor constructorInfo = targetEntity as InternalConstructor;
4118 if (null == constructorInfo) return;
4119
4120 IType targetType = null;
4121 if (NodeType.SuperLiteralExpression == node.Target.NodeType)
4122 {
4123 constructorInfo.HasSuperCall = true;
4124 targetType = constructorInfo.DeclaringType.BaseType;
4125 }
4126 else if (node.Target.NodeType == NodeType.SelfLiteralExpression)
4127 {
4128 constructorInfo.HasSelfCall = true;
4129 targetType = constructorInfo.DeclaringType;
4130 }
4131
4132 IConstructor targetConstructorInfo = GetCorrectConstructor(node, targetType, node.Arguments);
4133 if (null != targetConstructorInfo)
4134 {
4135 Bind(node.Target, targetConstructorInfo);
4136 }
4137 }
4138
4139 protected virtual bool ProcessMethodInvocationWithInvalidParameters(MethodInvocationExpression node, IMethod targetMethod)
4140 {
4141 return false;
4142 }
4143
4144 protected virtual void ProcessMethodInvocation(MethodInvocationExpression node, IEntity targetEntity)
4145 {
4146 IMethod targetMethod = (IMethod)targetEntity;
4147 if (!CheckParameters(targetMethod.CallableType, node.Arguments, false)
4148 || !IsAccessible(targetMethod))
4149 {
4150 if (TryToProcessAsExtensionInvocation(node)) return;
4151
4152 if (ProcessMethodInvocationWithInvalidParameters(node, targetMethod)) return;
4153
4154 AssertParameters(node, targetMethod, node.Arguments);
4155 }
4156
4157 AssertTargetContext(node.Target, targetMethod);
4158 NamedArgumentsNotAllowed(node);
4159
4160 EnsureRelatedNodeWasVisited(node.Target, targetMethod);
4161 BindExpressionType(node, GetInferredType(targetMethod));
4162 ApplyBuiltinMethodTypeInference(node, targetMethod);
4163 }
4164
4165 private bool IsAccessible(IAccessibleMember method)
4166 {
4167 return GetAccessibilityChecker().IsAccessible(method);
4168 }
4169
4170 private IAccessibilityChecker GetAccessibilityChecker()
4171 {
4172 if (null == _currentMethod) return AccessibilityChecker.Global;
4173 return new AccessibilityChecker(CurrentTypeDefinition);
4174 }
4175
4176 private TypeDefinition CurrentTypeDefinition
4177 {
4178 get { return _currentMethod.Method.DeclaringType; }
4179 }
4180
4181 private void NamedArgumentsNotAllowed(MethodInvocationExpression node)
4182 {
4183 if (node.NamedArguments.Count == 0) return;
4184 Error(CompilerErrorFactory.NamedArgumentsNotAllowed(node.NamedArguments[0]));
4185 }
4186
4187 private void ProcessExtensionMethodInvocation(MethodInvocationExpression node, IEntity targetEntity)
4188 {
4189 PreNormalizeExtensionInvocation(node);
4190 if (EntityType.Ambiguous == targetEntity.EntityType)
4191 {
4192 targetEntity = ResolveAmbiguousExtension(node, (Ambiguous)targetEntity);
4193 if (null == targetEntity) return;
4194 }
4195 IMethod targetMethod = (IMethod)targetEntity;
4196 PostNormalizationExtensionInvocation(node, targetMethod);
4197 NamedArgumentsNotAllowed(node);
4198 AssertParameters(node, targetMethod, node.Arguments);
4199 BindExpressionType(node, targetMethod.ReturnType);
4200 }
4201
4202 private IEntity ResolveAmbiguousExtension(MethodInvocationExpression node, Ambiguous ambiguous)
4203 {
4204 IEntity resolved = ResolveCallableReference(node, ambiguous);
4205 if (null != resolved) return resolved;
4206
4207 return CantResolveAmbiguousMethodInvocation(node, ambiguous.Entities);
4208 }
4209
4210 private bool IsExtensionMethod(IEntity entity)
4211 {
4212 if (EntityType.Method != entity.EntityType) return false;
4213 return ((IMethod)entity).IsExtension;
4214 }
4215
4216 private bool IsOrContainsBooExtensionMethod(IEntity entity)
4217 {
4218 if (entity.EntityType == EntityType.Ambiguous) return IsBooExtensionMethod(((Ambiguous)entity).Entities[0]);
4219 return IsBooExtensionMethod(entity);
4220 }
4221
4222 private bool IsBooExtensionMethod(IEntity entity)
4223 {
4224 if (EntityType.Method != entity.EntityType) return false;
4225 return ((IMethod)entity).IsBooExtension;
4226 }
4227
4228 private void PostNormalizationExtensionInvocation(MethodInvocationExpression node, IMethod targetMethod)
4229 {
4230 node.Target = CodeBuilder.CreateMethodReference(node.Target.LexicalInfo, targetMethod);
4231 }
4232
4233 private void PreNormalizeExtensionInvocation(MethodInvocationExpression node)
4234 {
4235 node.Arguments.Insert(0, EnsureMemberReferenceForExtension(node).Target);
4236 }
4237
4238 private MemberReferenceExpression EnsureMemberReferenceForExtension(MethodInvocationExpression node)
4239 {
4240 MemberReferenceExpression memberRef = node.Target as MemberReferenceExpression;
4241 if (null != memberRef) return memberRef;
4242
4243 node.Target = memberRef = CodeBuilder.MemberReferenceForEntity(
4244 CreateSelfReference(),
4245 GetEntity(node.Target));
4246
4247 return memberRef;
4248 }
4249
4250 private SelfLiteralExpression CreateSelfReference()
4251 {
4252 return CodeBuilder.CreateSelfReference(CurrentType);
4253 }
4254
4255 protected virtual bool IsDuckTyped(IMember entity)
4256 {
4257 return entity.IsDuckTyped;
4258 }
4259
4260 private IType GetInferredType(IMethod entity)
4261 {
4262 return IsDuckTyped(entity)
4263 ? this.TypeSystemServices.DuckType
4264 : entity.ReturnType;
4265 }
4266
4267 private IType GetInferredType(IMember entity)
4268 {
4269 Debug.Assert(EntityType.Method != entity.EntityType);
4270 return IsDuckTyped(entity)
4271 ? this.TypeSystemServices.DuckType
4272 : entity.Type;
4273 }
4274
4275 void ReplaceTypeInvocationByEval(IType type, MethodInvocationExpression node)
4276 {
4277 Node parent = node.ParentNode;
4278
4279 parent.Replace(node, EvalForTypeInvocation(type, node));
4280 }
4281
4282 private MethodInvocationExpression EvalForTypeInvocation(IType type, MethodInvocationExpression node)
4283 {
4284 MethodInvocationExpression eval = CodeBuilder.CreateEvalInvocation(node.LexicalInfo);
4285 ReferenceExpression local = CreateTempLocal(node.Target.LexicalInfo, type);
4286
4287 eval.Arguments.Add(CodeBuilder.CreateAssignment(local.CloneNode(), node));
4288
4289 AddResolvedNamedArgumentsToEval(eval, node.NamedArguments, local);
4290
4291 node.NamedArguments.Clear();
4292
4293 eval.Arguments.Add(local);
4294
4295 BindExpressionType(eval, type);
4296 return eval;
4297 }
4298
4299 private void AddResolvedNamedArgumentsToEval(MethodInvocationExpression eval, ExpressionPairCollection namedArguments, ReferenceExpression instance)
4300 {
4301 foreach (ExpressionPair pair in namedArguments)
4302 {
4303 if (TypeSystemServices.IsError(pair.First)) continue;
4304
4305 AddResolvedNamedArgumentToEval(eval, pair, instance);
4306 }
4307 }
4308
4309 protected virtual void AddResolvedNamedArgumentToEval(MethodInvocationExpression eval, ExpressionPair pair, ReferenceExpression instance)
4310 {
4311 IEntity entity = GetEntity(pair.First);
4312 switch (entity.EntityType)
4313 {
4314 case EntityType.Event:
4315 {
4316 IEvent member = (IEvent)entity;
4317 eval.Arguments.Add(
4318 CodeBuilder.CreateMethodInvocation(
4319 pair.First.LexicalInfo,
4320 instance.CloneNode(),
4321 member.GetAddMethod(),
4322 pair.Second));
4323 break;
4324 }
4325
4326 case EntityType.Field:
4327 {
4328 eval.Arguments.Add(
4329 CodeBuilder.CreateAssignment(
4330 pair.First.LexicalInfo,
4331 CodeBuilder.CreateMemberReference(
4332 instance.CloneNode(),
4333 (IMember)entity),
4334 pair.Second));
4335 break;
4336 }
4337
4338 case EntityType.Property:
4339 {
4340 IProperty property = (IProperty)entity;
4341 IMethod setter = property.GetSetMethod();
4342 if (null == setter)
4343 {
4344 Error(CompilerErrorFactory.PropertyIsReadOnly(
4345 pair.First,
4346 property.FullName));
4347 }
4348 else
4349 {
4350 //EnsureRelatedNodeWasVisited(pair.First, setter);
4351 eval.Arguments.Add(
4352 CodeBuilder.CreateAssignment(
4353 pair.First.LexicalInfo,
4354 CodeBuilder.CreateMemberReference(
4355 instance.CloneNode(),
4356 property),
4357 pair.Second));
4358 }
4359 break;
4360 }
4361 }
4362 }
4363
4364 void ProcessEventInvocation(IEvent ev, MethodInvocationExpression node)
4365 {
4366 NamedArgumentsNotAllowed(node);
4367 if (!EnsureInternalEventInvocation(ev, node)) return;
4368
4369 IMethod method = ev.GetRaiseMethod();
4370 if (AssertParameters(node, method, node.Arguments))
4371 {
4372 node.Target = CodeBuilder.CreateMemberReference(
4373 ((MemberReferenceExpression)node.Target).Target,
4374 method);
4375 BindExpressionType(node, method.ReturnType);
4376 }
4377 }
4378
4379 public bool EnsureInternalEventInvocation(IEvent ev, MethodInvocationExpression node)
4380 {
4381 if (ev.IsAbstract || ev.IsVirtual || ev.DeclaringType == CurrentType)
4382 return true;
4383
4384 Error(CompilerErrorFactory.EventCanOnlyBeInvokedFromWithinDeclaringClass(node, ev));
4385 return false;
4386 }
4387
4388 void ProcessCallableTypeInvocation(MethodInvocationExpression node, ICallableType type)
4389 {
4390 NamedArgumentsNotAllowed(node);
4391
4392 if (node.Arguments.Count == 1)
4393 {
4394 AssertTypeCompatibility(node.Arguments[0], type, GetExpressionType(node.Arguments[0]));
4395 node.ParentNode.Replace(
4396 node,
4397 CodeBuilder.CreateCast(
4398 type,
4399 node.Arguments[0]));
4400 }
4401 else
4402 {
4403 IConstructor ctor = GetCorrectConstructor(node, type, node.Arguments);
4404 if (null != ctor)
4405 {
4406 BindConstructorInvocation(node, ctor);
4407 }
4408 else
4409 {
4410 Error(node);
4411 }
4412 }
4413 }
4414
4415 void ProcessTypeInvocation(MethodInvocationExpression node)
4416 {
4417 IType type = (IType)node.Target.Entity;
4418
4419 ICallableType callableType = type as ICallableType;
4420 if (null != callableType)
4421 {
4422 ProcessCallableTypeInvocation(node, callableType);
4423 return;
4424 }
4425
4426 if (!AssertCanCreateInstance(node.Target, type))
4427 {
4428 Error(node);
4429 return;
4430 }
4431
4432 ResolveNamedArguments(type, node.NamedArguments);
4433 if (type.IsValueType && node.Arguments.Count == 0)
4434 {
4435 ProcessValueTypeInstantiation(type, node);
4436 return;
4437 }
4438
4439 IConstructor ctor = GetCorrectConstructor(node, type, node.Arguments);
4440 if (null != ctor)
4441 {
4442 BindConstructorInvocation(node, ctor);
4443
4444 if (node.NamedArguments.Count > 0)
4445 {
4446 ReplaceTypeInvocationByEval(type, node);
4447 }
4448 }
4449 else
4450 {
4451 Error(node);
4452 }
4453 }
4454
4455 void BindConstructorInvocation(MethodInvocationExpression node, IConstructor ctor)
4456 {
4457 // rebind the target now we know
4458 // it is a constructor call
4459 Bind(node.Target, ctor);
4460 BindExpressionType(node.Target, ctor.Type);
4461 BindExpressionType(node, ctor.DeclaringType);
4462 }
4463
4464 private void ProcessValueTypeInstantiation(IType type, MethodInvocationExpression node)
4465 {
4466 // XXX: naive and unoptimized but correct approach
4467 // simply initialize a new temporary value type
4468 // TODO: OPTIMIZE by detecting assignments to local variables
4469
4470 MethodInvocationExpression eval = CodeBuilder.CreateEvalInvocation(node.LexicalInfo);
4471 BindExpressionType(eval, type);
4472
4473 InternalLocal local = DeclareTempLocal(type);
4474 ReferenceExpression localReference = CodeBuilder.CreateReference(local);
4475 eval.Arguments.Add(CodeBuilder.CreateDefaultInitializer(node.LexicalInfo, local));
4476 AddResolvedNamedArgumentsToEval(eval, node.NamedArguments, localReference);
4477 eval.Arguments.Add(localReference);
4478
4479 node.ParentNode.Replace(node, eval);
4480 }
4481
4482 void ProcessGenericMethodInvocation(MethodInvocationExpression node)
4483 {
4484 IType type = GetExpressionType(node.Target);
4485 if (TypeSystemServices.IsCallable(type))
4486 {
4487 ProcessMethodInvocationOnCallableExpression(node);
4488 }
4489 else
4490 {
4491 Error(node,
4492 CompilerErrorFactory.TypeIsNotCallable(node.Target, type.ToString()));
4493 }
4494 }
4495
4496 void ProcessMethodInvocationOnCallableExpression(MethodInvocationExpression node)
4497 {
4498 IType type = node.Target.ExpressionType;
4499
4500 ICallableType delegateType = type as ICallableType;
4501 if (null != delegateType)
4502 {
4503 if (AssertParameters(node.Target, delegateType, delegateType, node.Arguments))
4504 {
4505 IMethod invoke = ResolveMethod(delegateType, "Invoke");
4506 node.Target = CodeBuilder.CreateMemberReference(node.Target, invoke);
4507 BindExpressionType(node, invoke.ReturnType);
4508 }
4509 else
4510 {
4511 Error(node);
4512 }
4513 }
4514 else if (TypeSystemServices.ICallableType.IsAssignableFrom(type))
4515 {
4516 node.Target = CodeBuilder.CreateMemberReference(node.Target, ICallable_Call);
4517 ArrayLiteralExpression arg = CodeBuilder.CreateObjectArray(node.Arguments);
4518 node.Arguments.Clear();
4519 node.Arguments.Add(arg);
4520
4521 BindExpressionType(node, ICallable_Call.ReturnType);
4522 }
4523 else if (TypeSystemServices.TypeType == type)
4524 {
4525 ProcessSystemTypeInvocation(node);
4526 }
4527 else
4528 {
4529 ProcessInvocationOnUnknownCallableExpression(node);
4530 }
4531 }
4532
4533 private void ProcessSystemTypeInvocation(MethodInvocationExpression node)
4534 {
4535 MethodInvocationExpression invocation = CreateInstanceInvocationFor(node);
4536 if (invocation.NamedArguments.Count == 0)
4537 {
4538 node.ParentNode.Replace(node, invocation);
4539 return;
4540 }
4541 ProcessNamedArgumentsForTypeInvocation(invocation);
4542 node.ParentNode.Replace(node, EvalForTypeInvocation(TypeSystemServices.ObjectType, invocation));
4543 }
4544
4545 private void ProcessNamedArgumentsForTypeInvocation(MethodInvocationExpression invocation)
4546 {
4547 foreach (ExpressionPair pair in invocation.NamedArguments)
4548 {
4549 if (!ProcessNamedArgument(pair)) continue;
4550 NamedArgumentNotFound(TypeSystemServices.ObjectType, (ReferenceExpression)pair.First);
4551 }
4552 }
4553
4554 private MethodInvocationExpression CreateInstanceInvocationFor(MethodInvocationExpression node)
4555 {
4556 MethodInvocationExpression invocation = CodeBuilder.CreateMethodInvocation(Activator_CreateInstance, node.Target);
4557 if (Activator_CreateInstance.AcceptVarArgs)
4558 {
4559 invocation.Arguments.Extend(node.Arguments);
4560 }
4561 else
4562 {
4563 invocation.Arguments.Add(CodeBuilder.CreateObjectArray(node.Arguments));
4564 }
4565 invocation.NamedArguments = node.NamedArguments;
4566 return invocation;
4567 }
4568
4569 protected virtual void ProcessInvocationOnUnknownCallableExpression(MethodInvocationExpression node)
4570 {
4571 NotImplemented(node, "Method invocation on type '" + node.Target.ExpressionType + "'.");
4572 }
4573
4574 bool AssertIdentifierName(Node node, string name)
4575 {
4576 if (TypeSystemServices.IsPrimitive(name))
4577 {
4578 Error(CompilerErrorFactory.CantRedefinePrimitive(node, name));
4579 return false;
4580 }
4581 return true;
4582 }
4583
4584 private bool CheckIsNotValueType(BinaryExpression node, Expression expression)
4585 {
4586 IType tag = GetExpressionType(expression);
4587 if (tag.IsValueType)
4588 {
4589 Error(CompilerErrorFactory.OperatorCantBeUsedWithValueType(
4590 expression,
4591 GetBinaryOperatorText(node.Operator),
4592 tag.ToString()));
4593
4594 return false;
4595 }
4596 return true;
4597 }
4598
4599 void BindAssignmentToSlice(BinaryExpression node)
4600 {
4601 SlicingExpression slice = (SlicingExpression)node.Left;
4602
4603 if (!IsAmbiguous(slice.Target.Entity)
4604 && GetExpressionType(slice.Target).IsArray)
4605 {
4606 BindAssignmentToSliceArray(node);
4607 }
4608 else if (TypeSystemServices.IsDuckTyped(slice.Target))
4609 {
4610 BindExpressionType(node, TypeSystemServices.DuckType);
4611 }
4612 else
4613 {
4614 BindAssignmentToSliceProperty(node);
4615 }
4616 }
4617
4618 void BindAssignmentToSliceArray(BinaryExpression node)
4619 {
4620 SlicingExpression slice = (SlicingExpression)node.Left;
4621
4622 IArrayType sliceTargetType = (IArrayType)GetExpressionType(slice.Target);
4623 IType lhsType = GetExpressionType(node.Right);
4624
4625 foreach (Slice item in slice.Indices)
4626 {
4627 if (!AssertTypeCompatibility(item.Begin, TypeSystemServices.IntType, GetExpressionType(item.Begin)))
4628 {
4629 Error(node);
4630 return;
4631 }
4632 }
4633
4634 if (slice.Indices.Count > 1)
4635 {
4636 if (AstUtil.IsComplexSlicing(slice))
4637 {
4638 // FIXME: Check type compatibility
4639 BindAssignmentToComplexSliceArray(node);
4640 }
4641 else
4642 {
4643 if (!AssertTypeCompatibility(node.Right, sliceTargetType.GetElementType(), lhsType))
4644 {
4645 Error(node);
4646 return;
4647 }
4648 BindAssignmentToSimpleSliceArray(node);
4649 }
4650 }
4651 else
4652 {
4653 if (!AssertTypeCompatibility(node.Right, sliceTargetType.GetElementType(), lhsType))
4654 {
4655 Error(node);
4656 return;
4657 }
4658 node.ExpressionType = sliceTargetType.GetElementType();
4659 }
4660 }
4661
4662 void BindAssignmentToSimpleSliceArray(BinaryExpression node)
4663 {
4664 SlicingExpression slice = (SlicingExpression)node.Left;
4665 MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
4666 slice.Target,
4667 TypeSystemServices.Map(typeof(Array).GetMethod("SetValue", new Type[] { typeof(object), typeof(int[]) })),
4668 node.Right);
4669 for (int i = 0; i < slice.Indices.Count; i++)
4670 {
4671 mie.Arguments.Add(slice.Indices[i].Begin);
4672 }
4673 BindExpressionType(mie, TypeSystemServices.VoidType);
4674 node.ParentNode.Replace(node, mie);
4675 }
4676
4677 void BindAssignmentToComplexSliceArray(BinaryExpression node)
4678 {
4679 SlicingExpression slice = (SlicingExpression)node.Left;
4680 ArrayLiteralExpression ale = new ArrayLiteralExpression();
4681 ArrayLiteralExpression collapse = new ArrayLiteralExpression();
4682 for (int i = 0; i < slice.Indices.Count; i++)
4683 {
4684 ale.Items.Add(slice.Indices[i].Begin);
4685 if (null == slice.Indices[i].End ||
4686 OmittedExpression.Default == slice.Indices[i].End)
4687 {
4688 ale.Items.Add(new IntegerLiteralExpression(1 + (int)((IntegerLiteralExpression)slice.Indices[i].Begin).Value));
4689 collapse.Items.Add(new BoolLiteralExpression(true));
4690 }
4691 else
4692 {
4693 ale.Items.Add(slice.Indices[i].End);
4694 collapse.Items.Add(new BoolLiteralExpression(false));
4695 }
4696 }
4697
4698 MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
4699 RuntimeServices_SetMultiDimensionalRange1,
4700 node.Right,
4701 slice.Target,
4702 ale);
4703
4704 mie.Arguments.Add(collapse);
4705
4706 BindExpressionType(mie, TypeSystemServices.VoidType);
4707 BindExpressionType(ale, TypeSystemServices.Map(typeof(int[])));
4708 BindExpressionType(collapse, TypeSystemServices.Map(typeof(bool[])));
4709 node.ParentNode.Replace(node, mie);
4710 }
4711
4712 void BindAssignmentToSliceProperty(BinaryExpression node)
4713 {
4714 SlicingExpression slice = (SlicingExpression)node.Left;
4715
4716 IEntity lhs = GetEntity(node.Left);
4717 IMethod setter = null;
4718
4719 MethodInvocationExpression mie = new MethodInvocationExpression(node.Left.LexicalInfo);
4720 foreach (Slice index in slice.Indices)
4721 {
4722 mie.Arguments.Add(index.Begin);
4723 }
4724 mie.Arguments.Add(node.Right);
4725
4726 if (EntityType.Property == lhs.EntityType)
4727 {
4728 IMethod setMethod = ((IProperty)lhs).GetSetMethod();
4729 if (null == setMethod)
4730 {
4731 Error(node, CompilerErrorFactory.PropertyIsReadOnly(slice.Target, lhs.FullName));
4732 return;
4733 }
4734 if (AssertParameters(node.Left, setMethod, mie.Arguments))
4735 {
4736 setter = setMethod;
4737 }
4738 }
4739 else if (EntityType.Ambiguous == lhs.EntityType)
4740 {
4741 setter = (IMethod)GetCorrectCallableReference(node.Left, mie.Arguments, GetSetMethods(lhs));
4742 if (setter == null)
4743 {
4744 Error(node.Left);
4745 return;
4746 }
4747 }
4748
4749 if (null == setter)
4750 {
4751 Error(node, CompilerErrorFactory.LValueExpected(node.Left));
4752 }
4753 else
4754 {
4755 mie.Target = CodeBuilder.CreateMemberReference(
4756 GetIndexedPropertySlicingTarget(slice),
4757 setter);
4758 BindExpressionType(mie, setter.ReturnType);
4759 node.ParentNode.Replace(node, mie);
4760 }
4761 }
4762
4763 private IEntity[] GetSetMethods(IEntity candidates)
4764 {
4765 return GetSetMethods(((Ambiguous)candidates).Entities);
4766 }
4767
4768 void BindAssignment(BinaryExpression node)
4769 {
4770 BindNullableOperation(node);
4771
4772 if (NodeType.SlicingExpression == node.Left.NodeType)
4773 {
4774 BindAssignmentToSlice(node);
4775 }
4776 else
4777 {
4778 ProcessAssignment(node);
4779 }
4780 }
4781
4782 virtual protected void ProcessAssignment(BinaryExpression node)
4783 {
4784 TryToResolveAmbiguousAssignment(node);
4785 ValidateAssignment(node);
4786 BindExpressionType(node, GetExpressionType(node.Right));
4787 }
4788
4789 virtual protected void ValidateAssignment(BinaryExpression node)
4790 {
4791 IEntity lhs = node.Left.Entity;
4792 IType rtype = GetExpressionType(node.Right);
4793 if (AssertLValue(node.Left, lhs))
4794 {
4795 IType lhsType = GetExpressionType(node.Left);
4796 AssertTypeCompatibility(node.Right, lhsType, rtype);
4797 CheckAssignmentToIndexedProperty(node.Left, lhs);
4798 }
4799 }
4800
4801 virtual protected void TryToResolveAmbiguousAssignment(BinaryExpression node)
4802 {
4803 IEntity lhs = node.Left.Entity;
4804 if (null == lhs) return;
4805 if (EntityType.Ambiguous != lhs.EntityType) return;
4806
4807 Expression lvalue = node.Left;
4808 lhs = ResolveAmbiguousLValue(lvalue, (Ambiguous)lhs, node.Right);
4809 if (NodeType.ReferenceExpression == lvalue.NodeType)
4810 {
4811 IMember member = lhs as IMember;
4812 if (null != member)
4813 {
4814 ResolveMemberInfo((ReferenceExpression)lvalue, member);
4815 }
4816 }
4817 }
4818
4819 private void CheckAssignmentToIndexedProperty(Node node, IEntity lhs)
4820 {
4821 IProperty property = lhs as IProperty;
4822 if (null != property && IsIndexedProperty(property))
4823 {
4824 Error(CompilerErrorFactory.PropertyRequiresParameters(AstUtil.GetMemberAnchor(node), property.FullName));
4825 }
4826 }
4827
4828 bool CheckIsaArgument(Expression e)
4829 {
4830 if (TypeSystemServices.TypeType != GetExpressionType(e))
4831 {
4832 Error(CompilerErrorFactory.IsaArgument(e));
4833 return false;
4834 }
4835 return true;
4836 }
4837
4838 bool BindNullableOperation(BinaryExpression node)
4839 {
4840 if (!IsNullableOperation(node))
4841 {
4842 return false;
4843 }
4844
4845 if (BinaryOperatorType.ReferenceEquality == node.Operator)
4846 {
4847 node.Operator = BinaryOperatorType.Equality;
4848 }
4849 else if (BinaryOperatorType.ReferenceInequality == node.Operator)
4850 {
4851 node.Operator = BinaryOperatorType.Inequality;
4852 }
4853
4854 IType lhs, rhs;
4855 if (BinaryOperatorType.Assign == node.Operator)
4856 {
4857 lhs = GetExpressionType(node.Left);
4858 rhs = GetExpressionType(node.Right);
4859 bool lhsIsNullable = TypeSystemServices.IsNullable(lhs);
4860 if (lhsIsNullable && TypeSystemServices.IsNullable(rhs))
4861 {
4862 return false;
4863 }
4864 if (lhsIsNullable)
4865 {
4866 BindNullableInitializer(node, node.Right, lhs);
4867 return false;
4868 }
4869 }
4870 else if (IsNull(node.Left) || IsNull(node.Right))
4871 {
4872 Expression nullable = IsNull(node.Left) ? node.Right : node.Left;
4873 Expression val = new MemberReferenceExpression(nullable, "HasValue");
4874 node.Replace(node.Left, val);
4875 Visit(val);
4876 Expression nil = new BoolLiteralExpression(false);
4877 node.Replace(node.Right, nil);
4878 Visit(nil);
4879 BindExpressionType(node, TypeSystemServices.BoolType);
4880 return true;
4881 }
4882
4883 if (BinaryOperatorType.Equality != node.Operator
4884 && BinaryOperatorType.Inequality != node.Operator)
4885 {
4886 lhs = GetExpressionType(node.Left);
4887 if (TypeSystemServices.IsNullable(lhs))
4888 {
4889 Expression val = new MemberReferenceExpression(node.Left, "Value");
4890 node.Replace(node.Left, val);
4891 Visit(val);
4892 }
4893 rhs = GetExpressionType(node.Right);
4894 if (TypeSystemServices.IsNullable(rhs))
4895 {
4896 Expression val = new MemberReferenceExpression(node.Right, "Value");
4897 node.Replace(node.Right, val);
4898 Visit(val);
4899 }
4900 }
4901
4902 return false;
4903 }
4904
4905 void BindNullableInitializer(Node node, Expression val, IType type)
4906 {
4907 MethodInvocationExpression mie = new MethodInvocationExpression();
4908 GenericReferenceExpression gre = new GenericReferenceExpression();
4909 gre.Target = new MemberReferenceExpression(new ReferenceExpression("System"), "Nullable");
4910 gre.GenericArguments.Add(TypeReference.Lift(Nullable.GetUnderlyingType(((ExternalType) type).ActualType)));
4911 mie.Target = gre;
4912 if (!IsNull(val))
4913 {
4914 mie.Arguments.Add(val);
4915 }
4916 node.Replace(val, mie);
4917 Visit(mie);
4918 }
4919
4920 void BindTypeTest(BinaryExpression node)
4921 {
4922 if (CheckIsNotValueType(node, node.Left) &&
4923 CheckIsaArgument(node.Right))
4924 {
4925 BindExpressionType(node, TypeSystemServices.BoolType);
4926 }
4927 else
4928 {
4929 Error(node);
4930 }
4931 }
4932
4933 void BindReferenceEquality(BinaryExpression node)
4934 {
4935 if (BindNullableOperation(node))
4936 {
4937 return;
4938 }
4939
4940 if (CheckIsNotValueType(node, node.Left) &&
4941 CheckIsNotValueType(node, node.Right))
4942 {
4943 BindExpressionType(node, TypeSystemServices.BoolType);
4944 }
4945 else
4946 {
4947 Error(node);
4948 }
4949 }
4950
4951 void BindInPlaceArithmeticOperator(BinaryExpression node)
4952 {
4953 if (IsArraySlicing(node.Left))
4954 {
4955 BindInPlaceArithmeticOperatorOnArraySlicing(node);
4956 return;
4957 }
4958
4959 Node parent = node.ParentNode;
4960
4961 Expression target = node.Left;
4962 if (null != target.Entity && EntityType.Property == target.Entity.EntityType)
4963 {
4964 // if target is a property force a rebinding
4965 target.ExpressionType = null;
4966 }
4967
4968 BinaryExpression assign = ExpandInPlaceBinaryExpression(node);
4969 parent.Replace(node, assign);
4970 Visit(assign);
4971 }
4972
4973 protected BinaryExpression ExpandInPlaceBinaryExpression(BinaryExpression node)
4974 {
4975 BinaryExpression assign = new BinaryExpression(node.LexicalInfo);
4976 assign.Operator = BinaryOperatorType.Assign;
4977 assign.Left = node.Left.CloneNode();
4978 assign.Right = node;
4979 node.Operator = GetRelatedBinaryOperatorForInPlaceOperator(node.Operator);
4980 return assign;
4981 }
4982
4983 private void BindInPlaceArithmeticOperatorOnArraySlicing(BinaryExpression node)
4984 {
4985 Node parent = node.ParentNode;
4986 Expression expansion = CreateSideEffectAwareSlicingOperation(
4987 node.LexicalInfo,
4988 GetRelatedBinaryOperatorForInPlaceOperator(node.Operator),
4989 (SlicingExpression) node.Left,
4990 node.Right,
4991 null);
4992 parent.Replace(node, expansion);
4993 }
4994
4995 BinaryOperatorType GetRelatedBinaryOperatorForInPlaceOperator(BinaryOperatorType op)
4996 {
4997 switch (op)
4998 {
4999 case BinaryOperatorType.InPlaceAddition:
5000 return BinaryOperatorType.Addition;
5001
5002 case BinaryOperatorType.InPlaceSubtraction:
5003 return BinaryOperatorType.Subtraction;
5004
5005 case BinaryOperatorType.InPlaceMultiply:
5006 return BinaryOperatorType.Multiply;
5007
5008 case BinaryOperatorType.InPlaceDivision:
5009 return BinaryOperatorType.Division;
5010
5011 case BinaryOperatorType.InPlaceBitwiseAnd:
5012 return BinaryOperatorType.BitwiseAnd;
5013
5014 case BinaryOperatorType.InPlaceBitwiseOr:
5015 return BinaryOperatorType.BitwiseOr;
5016
5017 case BinaryOperatorType.InPlaceShiftLeft:
5018 return BinaryOperatorType.ShiftLeft;
5019
5020 case BinaryOperatorType.InPlaceShiftRight:
5021 return BinaryOperatorType.ShiftRight;
5022 }
5023 throw new ArgumentException("op");
5024 }
5025
5026 void BindArrayAddition(BinaryExpression node)
5027 {
5028 IArrayType lhs = (IArrayType)GetExpressionType(node.Left);
5029 IArrayType rhs = (IArrayType)GetExpressionType(node.Right);
5030
5031 if (lhs.GetElementType() == rhs.GetElementType())
5032 {
5033 node.ParentNode.Replace(
5034 node,
5035 CodeBuilder.CreateCast(
5036 lhs,
5037 CodeBuilder.CreateMethodInvocation(
5038 RuntimeServices_AddArrays,
5039 CodeBuilder.CreateTypeofExpression(lhs.GetElementType()),
5040 node.Left,
5041 node.Right)));
5042 }
5043 else
5044 {
5045 InvalidOperatorForTypes(node);
5046 }
5047 }
5048
5049 void BindArithmeticOperator(BinaryExpression node)
5050 {
5051 BindNullableOperation(node);
5052
5053 IType left = GetExpressionType(node.Left);
5054 IType right = GetExpressionType(node.Right);
5055 if (IsPrimitiveNumber(left) && IsPrimitiveNumber(right))
5056 {
5057 BindExpressionType(node, TypeSystemServices.GetPromotedNumberType(left, right));
5058 }
5059 else if (!ResolveOperator(node))
5060 {
5061 InvalidOperatorForTypes(node);
5062 }
5063 }
5064
5065 static string GetBinaryOperatorText(BinaryOperatorType op)
5066 {
5067 return BooPrinterVisitor.GetBinaryOperatorText(op);
5068 }
5069
5070 static string GetUnaryOperatorText(UnaryOperatorType op)
5071 {
5072 return BooPrinterVisitor.GetUnaryOperatorText(op);
5073 }
5074
5075 IEntity ResolveName(Node node, string name)
5076 {
5077 IEntity tag = NameResolutionService.Resolve(name);
5078 CheckNameResolution(node, name, tag);
5079
5080 return tag;
5081 }
5082
5083 bool CheckNameResolution(Node node, string name, IEntity tag)
5084 {
5085 if (null == tag)
5086 {
5087 Error(CompilerErrorFactory.UnknownIdentifier(node, name));
5088 return false;
5089 }
5090 return true;
5091 }
5092
5093 private bool IsPublicEvent(IEntity tag)
5094 {
5095 return (EntityType.Event == tag.EntityType) && ((IMember)tag).IsPublic;
5096 }
5097
5098 private bool IsPublicFieldPropertyEvent(IEntity entity)
5099 {
5100 return IsFieldPropertyOrEvent(entity) && ((IMember)entity).IsPublic;
5101 }
5102
5103 private static bool IsFieldPropertyOrEvent(IEntity entity)
5104 {
5105 return ((EntityType.Field|EntityType.Property|EntityType.Event) & entity.EntityType) > 0;
5106 }
5107
5108 private IMember ResolvePublicFieldPropertyEvent(Expression sourceNode, IType type, string name)
5109 {
5110 IEntity candidate = ResolveFieldPropertyEvent(type, name);
5111 if (null == candidate) return null;
5112
5113 if (IsPublicFieldPropertyEvent(candidate)) return (IMember)candidate;
5114
5115 if (candidate.EntityType != EntityType.Ambiguous) return null;
5116
5117 IList found = ((Ambiguous)candidate).Select(IsPublicFieldPropertyEvent);
5118 if (found.Count == 0) return null;
5119 if (found.Count == 1) return (IMember)found[0];
5120
5121 Error(sourceNode, CompilerErrorFactory.AmbiguousReference(sourceNode, name, found));
5122 return null;
5123 }
5124
5125 protected IEntity ResolveFieldPropertyEvent(IType type, string name)
5126 {
5127 return NameResolutionService.Resolve(type, name, EntityType.Property|EntityType.Event|EntityType.Field);
5128 }
5129
5130 void ResolveNamedArguments(IType type, ExpressionPairCollection arguments)
5131 {
5132 foreach (ExpressionPair arg in arguments)
5133 {
5134 if (!ProcessNamedArgument(arg)) continue;
5135 ResolveNamedArgument(type, (ReferenceExpression)arg.First, arg.Second);
5136 }
5137 }
5138
5139 private bool ProcessNamedArgument(ExpressionPair arg)
5140 {
5141 Visit(arg.Second);
5142 if (NodeType.ReferenceExpression != arg.First.NodeType)
5143 {
5144 Error(arg.First, CompilerErrorFactory.NamedParameterMustBeIdentifier(arg));
5145 return false;
5146 }
5147 return true;
5148 }
5149
5150 void ResolveNamedArgument(IType type, ReferenceExpression name, Expression value)
5151 {
5152 IMember member = ResolvePublicFieldPropertyEvent(name, type, name.Name);
5153 if (null == member)
5154 {
5155 NamedArgumentNotFound(type, name);
5156 return;
5157 }
5158
5159 EnsureRelatedNodeWasVisited(name, member);
5160 Bind(name, member);
5161
5162 IType memberType = member.Type;
5163 if (member.EntityType == EntityType.Event)
5164 {
5165 AssertDelegateArgument(value, member, GetExpressionType(value));
5166 }
5167 else
5168 {
5169 AssertTypeCompatibility(value, memberType, GetExpressionType(value));
5170 }
5171 }
5172
5173 protected virtual void NamedArgumentNotFound(IType type, ReferenceExpression name)
5174 {
5175 Error(name, CompilerErrorFactory.NotAPublicFieldOrProperty(name, type.ToString(), name.Name));
5176 }
5177
5178 bool AssertTypeCompatibility(Node sourceNode, IType expectedType, IType actualType)
5179 {
5180 if (TypeSystemServices.IsError(expectedType)
5181 || TypeSystemServices.IsError(actualType))
5182 {
5183 return false;
5184 }
5185
5186 if (!TypeSystemServices.AreTypesRelated(expectedType, actualType))
5187 {
5188 Error(CompilerErrorFactory.IncompatibleExpressionType(sourceNode, expectedType.ToString(), actualType.ToString()));
5189 return false;
5190 }
5191 return true;
5192 }
5193
5194 bool AssertDelegateArgument(Node sourceNode, ITypedEntity delegateMember, ITypedEntity argumentInfo)
5195 {
5196 if (!delegateMember.Type.IsAssignableFrom(argumentInfo.Type))
5197 {
5198 Error(CompilerErrorFactory.EventArgumentMustBeAMethod(sourceNode, delegateMember.FullName, delegateMember.Type.ToString()));
5199 return false;
5200 }
5201 return true;
5202 }
5203
5204 bool CheckParameterTypesStrictly(IMethod method, ExpressionCollection args)
5205 {
5206 IParameter[] parameters = method.GetParameters();
5207 for (int i=0; i<args.Count; ++i)
5208 {
5209 IType expressionType = GetExpressionType(args[i]);
5210 IType parameterType = parameters[i].Type;
5211 if (!IsAssignableFrom(parameterType, expressionType) &&
5212 !(IsNumber(expressionType) && IsNumber(parameterType))
5213 && TypeSystemServices.FindImplicitConversionOperator(expressionType,parameterType) == null)
5214 {
5215 return false;
5216 }
5217 }
5218 return true;
5219 }
5220
5221 bool AssertParameterTypes(ICallableType method, ExpressionCollection args, int count, bool reportErrors)
5222 {
5223 IParameter[] parameters = method.GetSignature().Parameters;
5224 for (int i=0; i<count; ++i)
5225 {
5226 IParameter param = parameters[i];
5227 IType parameterType = param.Type;
5228 IType argumentType = GetExpressionType(args[i]);
5229 if (param.IsByRef)
5230 {
5231 if (!(args[i] is ReferenceExpression
5232 || args[i] is SlicingExpression))
5233 {
5234 if (reportErrors) Error(CompilerErrorFactory.RefArgTakesLValue(args[i]));
5235 return false;
5236 }
5237 if (!_callableResolution.IsValidByRefArg(param, parameterType, argumentType, args[i]))
5238 {
5239 return false;
5240 }
5241 }
5242 else
5243 {
5244 if (!TypeSystemServices.AreTypesRelated(parameterType, argumentType))
5245 {
5246 return false;
5247 }
5248 }
5249 }
5250 return true;
5251 }
5252
5253 bool AssertParameters(Node sourceNode, IMethod method, ExpressionCollection args)
5254 {
5255 return AssertParameters(sourceNode, method, method.CallableType, args);
5256 }
5257
5258 bool AcceptVarArgs(ICallableType method)
5259 {
5260 return method.GetSignature().AcceptVarArgs;
5261 }
5262
5263 bool AssertParameters(Node sourceNode, IEntity sourceEntity, ICallableType method, ExpressionCollection args)
5264 {
5265 if (CheckParameters(method, args, true)) return true;
5266
5267 Error(CompilerErrorFactory.MethodSignature(sourceNode, sourceEntity.ToString(), GetSignature(args)));
5268 return false;
5269 }
5270
5271 private bool CheckParameters(ICallableType method, ExpressionCollection args, bool reportErrors)
5272 {
5273 return AcceptVarArgs(method)
5274 ? CheckVarArgsParameters(method, args)
5275 : CheckExactArgsParameters(method, args, reportErrors);
5276 }
5277
5278 bool CheckVarArgsParameters(ICallableType method, ExpressionCollection args)
5279 {
5280 return _callableResolution.IsValidVargsInvocation(method.GetSignature().Parameters, args);
5281 }
5282
5283 bool CheckExactArgsParameters(ICallableType method, ExpressionCollection args, bool reportErrors)
5284 {
5285 if (method.GetSignature().Parameters.Length != args.Count) return false;
5286 return AssertParameterTypes(method, args, args.Count, reportErrors);
5287 }
5288
5289 bool IsRuntimeIterator(IType type)
5290 {
5291 return TypeSystemServices.IsSystemObject(type)
5292 || IsTextReader(type);
5293 }
5294
5295 bool IsTextReader(IType type)
5296 {
5297 return IsAssignableFrom(typeof(TextReader), type);
5298 }
5299
5300 bool AssertTargetContext(Expression targetContext, IMember member)
5301 {
5302 if (member.IsStatic) return true;
5303 if (NodeType.MemberReferenceExpression != targetContext.NodeType) return true;
5304
5305 Expression targetReference = ((MemberReferenceExpression)targetContext).Target;
5306 IEntity entity = targetReference.Entity;
5307 if ((null != entity && EntityType.Type == entity.EntityType)
5308 || (NodeType.SelfLiteralExpression == targetReference.NodeType
5309 && _currentMethod.IsStatic))
5310 {
5311 Error(CompilerErrorFactory.InstanceRequired(targetContext, member.DeclaringType.ToString(), member.Name));
5312 return false;
5313 }
5314 return true;
5315 }
5316
5317 static bool IsAssignableFrom(IType expectedType, IType actualType)
5318 {
5319 return expectedType.IsAssignableFrom(actualType);
5320 }
5321
5322 bool IsAssignableFrom(Type expectedType, IType actualType)
5323 {
5324 return TypeSystemServices.Map(expectedType).IsAssignableFrom(actualType);
5325 }
5326
5327 bool IsNumber(IType type)
5328 {
5329 return TypeSystemServices.IsNumber(type);
5330 }
5331
5332 bool IsPrimitiveNumber(IType type)
5333 {
5334 return TypeSystemServices.IsPrimitiveNumber(type);
5335 }
5336
5337 bool IsPrimitiveNumber(Expression expression)
5338 {
5339 return IsPrimitiveNumber(GetExpressionType(expression));
5340 }
5341
5342 IConstructor GetCorrectConstructor(Node sourceNode, IType type, ExpressionCollection arguments)
5343 {
5344 IConstructor[] constructors = type.GetConstructors();
5345 if (null != constructors && constructors.Length > 0)
5346 {
5347 return (IConstructor)GetCorrectCallableReference(sourceNode, arguments, constructors);
5348 }
5349 else
5350 {
5351 if (!TypeSystemServices.IsError(type))
5352 {
5353 if (null == (type as IGenericParameter))
5354 {
5355 Error(CompilerErrorFactory.NoApropriateConstructorFound(sourceNode, type.ToString(), GetSignature(arguments)));
5356 }
5357 else
5358 {
5359 Error(CompilerErrorFactory.CannotCreateAnInstanceOfGenericParameterWithoutDefaultConstructorConstraint(sourceNode, type.ToString()));
5360 }
5361 }
5362 }
5363 return null;
5364 }
5365
5366 IEntity GetCorrectCallableReference(Node sourceNode, ExpressionCollection args, IEntity[] candidates)
5367 {
5368 // BOO-844: Ensure all candidates were visited (to make property setters have correct signature)
5369 foreach (IEntity candidate in candidates)
5370 {
5371 EnsureRelatedNodeWasVisited(sourceNode, candidate);
5372 }
5373
5374 IEntity found = _callableResolution.ResolveCallableReference(args, candidates);
5375 if (null == found) EmitCallableResolutionError(sourceNode, candidates, args);
5376 return found;
5377 }
5378
5379 private void EmitCallableResolutionError(Node sourceNode, IEntity[] candidates, ExpressionCollection args)
5380 {
5381 if (_callableResolution.ValidCandidates.Count > 1)
5382 {
5383 Error(CompilerErrorFactory.AmbiguousReference(sourceNode, candidates[0].Name, _callableResolution.ValidCandidates));
5384 }
5385 else
5386 {
5387 IEntity candidate = candidates[0];
5388 IConstructor constructor = candidate as IConstructor;
5389 if (null != constructor)
5390 {
5391 Error(CompilerErrorFactory.NoApropriateConstructorFound(sourceNode, constructor.DeclaringType.ToString(), GetSignature(args)));
5392 }
5393 else
5394 {
5395 Error(CompilerErrorFactory.NoApropriateOverloadFound(sourceNode, GetSignature(args), candidate.FullName));
5396 }
5397 }
5398 }
5399
5400 override protected void EnsureRelatedNodeWasVisited(Node sourceNode, IEntity entity)
5401 {
5402 IInternalEntity internalInfo = entity as IInternalEntity;
5403 if (null == internalInfo)
5404 {
5405 ITypedEntity typedEntity = entity as ITypedEntity;
5406 if (null == typedEntity) return;
5407
5408 internalInfo = typedEntity.Type as IInternalEntity;
5409 if (null == internalInfo) return;
5410 }
5411
5412 Node node = internalInfo.Node;
5413
5414 //member has been used so remove private member unused annotation
5415 TypeMember member = node as TypeMember;
5416 if (null != member
5417 && member.IsPrivate
5418 && member.ContainsAnnotation("PrivateMemberNeverUsed"))
5419 {
5420 node.RemoveAnnotation("PrivateMemberNeverUsed");
5421 }
5422
5423 switch (node.NodeType)
5424 {
5425 case NodeType.Property:
5426 case NodeType.Field:
5427 {
5428 IMember memberEntity = (IMember)entity;
5429 if (EntityType.Property == entity.EntityType
5430 || TypeSystemServices.IsUnknown(memberEntity.Type))
5431 {
5432 VisitMemberForTypeResolution(node);
5433 AssertTypeIsKnown(sourceNode, memberEntity, memberEntity.Type);
5434 }
5435 break;
5436 }
5437
5438 case NodeType.Method:
5439 {
5440 IMethod methodEntity = (IMethod)entity;
5441 if (TypeSystemServices.IsUnknown(methodEntity.ReturnType))
5442 {
5443 // try to preprocess the method to resolve its return type
5444 Method method = (Method)node;
5445 PreProcessMethod(method);
5446 if (TypeSystemServices.IsUnknown(methodEntity.ReturnType))
5447 {
5448 // still unknown?
5449 VisitMemberForTypeResolution(node);
5450 AssertTypeIsKnown(sourceNode, methodEntity, methodEntity.ReturnType);
5451 }
5452 }
5453 break;
5454 }
5455 case NodeType.ClassDefinition:
5456 case NodeType.StructDefinition:
5457 case NodeType.InterfaceDefinition:
5458 {
5459 if (WasVisited(node)) break;
5460 VisitInParentNamespace(node);
5461 //visit dependent attributes such as EnumeratorItemType
5462 //foreach (Attribute att in ((TypeDefinition)node).Attributes)
5463 {
5464 //VisitMemberForTypeResolution(att);
5465 }
5466 break;
5467 }
5468 }
5469 }
5470
5471 private void VisitInParentNamespace(Node node)
5472 {
5473 INamespace saved = NameResolutionService.CurrentNamespace;
5474 try
5475 {
5476 NameResolutionService.EnterNamespace((INamespace)node.ParentNode.Entity);
5477 Visit(node);
5478 }
5479 finally
5480 {
5481 NameResolutionService.Restore(saved);
5482 }
5483 }
5484
5485
5486 private void AssertTypeIsKnown(Node sourceNode, IEntity sourceEntity, IType type)
5487 {
5488 if (TypeSystemServices.IsUnknown(type))
5489 {
5490 Error(
5491 CompilerErrorFactory.UnresolvedDependency(
5492 sourceNode,
5493 CurrentMember.FullName,
5494 sourceEntity.FullName));
5495 }
5496 }
5497
5498 void VisitMemberForTypeResolution(Node node)
5499 {
5500 if (WasVisited(node)) return;
5501
5502 _context.TraceVerbose("Info {0} needs resolving.", node.Entity.Name);
5503 INamespace saved = NameResolutionService.CurrentNamespace;
5504 try
5505 {
5506 Visit(node);
5507 }
5508 finally
5509 {
5510 NameResolutionService.Restore(saved);
5511 }
5512 }
5513
5514 bool ResolveOperator(UnaryExpression node)
5515 {
5516 MethodInvocationExpression mie = new MethodInvocationExpression(node.LexicalInfo);
5517 mie.Arguments.Add(node.Operand.CloneNode());
5518
5519 string operatorName = AstUtil.GetMethodNameForOperator(node.Operator);
5520 IType operand = GetExpressionType(node.Operand);
5521 if (ResolveOperator(node, operand, operatorName, mie))
5522 {
5523 return true;
5524 }
5525 return ResolveOperator(node, TypeSystemServices.RuntimeServicesType, operatorName, mie);
5526 }
5527
5528 bool ResolveOperator(BinaryExpression node)
5529 {
5530 MethodInvocationExpression mie = new MethodInvocationExpression(node.LexicalInfo);
5531 mie.Arguments.Add(node.Left.CloneNode());
5532 mie.Arguments.Add(node.Right.CloneNode());
5533
5534 string operatorName = AstUtil.GetMethodNameForOperator(node.Operator);
5535 IType lhs = GetExpressionType(node.Left);
5536 if (ResolveOperator(node, lhs, operatorName, mie))
5537 {
5538 return true;
5539 }
5540
5541 IType rhs = GetExpressionType(node.Right);
5542 if (ResolveOperator(node, rhs, operatorName, mie))
5543 {
5544 return true;
5545 }
5546 return ResolveRuntimeOperator(node, operatorName, mie);
5547 }
5548
5549 protected virtual bool ResolveRuntimeOperator(BinaryExpression node, string operatorName, MethodInvocationExpression mie)
5550 {
5551 return ResolveOperator(node, TypeSystemServices.RuntimeServicesType, operatorName, mie);
5552 }
5553
5554 IMethod ResolveAmbiguousOperator(IEntity[] entities, ExpressionCollection args)
5555 {
5556 foreach (IEntity entity in entities)
5557 {
5558 IMethod method = entity as IMethod;
5559 if (null != method)
5560 {
5561 if (HasOperatorSignature(method, args))
5562 {
5563 return method;
5564 }
5565 }
5566 }
5567 return null;
5568 }
5569
5570 bool HasOperatorSignature(IMethod method, ExpressionCollection args)
5571 {
5572 return method.IsStatic &&
5573 (args.Count == method.GetParameters().Length) &&
5574 CheckParameterTypesStrictly(method, args);
5575 }
5576
5577 IMethod FindOperator(IType type, string operatorName, ExpressionCollection args)
5578 {
5579 IEntity entity = NameResolutionService.Resolve(type, operatorName, EntityType.Method);
5580 if (null != entity)
5581 {
5582 IMethod method = ResolveOperatorEntity(entity, args);
5583 if (null != method) return method;
5584 }
5585
5586 entity = NameResolutionService.ResolveExtension(type, operatorName);
5587 if (null != entity)
5588 {
5589 return ResolveOperatorEntity(entity, args);
5590 }
5591
5592 return null;
5593 }
5594
5595 private IMethod ResolveOperatorEntity(IEntity op, ExpressionCollection args)
5596 {
5597 if (EntityType.Ambiguous == op.EntityType)
5598 {
5599 return ResolveAmbiguousOperator(((Ambiguous)op).Entities, args);
5600 }
5601
5602 if (EntityType.Method == op.EntityType)
5603 {
5604 IMethod candidate = (IMethod)op;
5605 if (HasOperatorSignature(candidate, args))
5606 {
5607 return candidate;
5608 }
5609 }
5610 return null;
5611 }
5612
5613 bool ResolveOperator(Expression node, IType type, string operatorName, MethodInvocationExpression mie)
5614 {
5615 IMethod entity = FindOperator(type, operatorName, mie.Arguments);
5616 if (null == entity) return false;
5617 EnsureRelatedNodeWasVisited(node, entity);
5618
5619 mie.Target = new ReferenceExpression(entity.FullName);
5620
5621 IMethod operatorMethod = entity;
5622 BindExpressionType(mie, operatorMethod.ReturnType);
5623 BindExpressionType(mie.Target, operatorMethod.Type);
5624 Bind(mie.Target, entity);
5625
5626 node.ParentNode.Replace(node, mie);
5627
5628 return true;
5629 }
5630
5631 Expression AssertBoolContext(Expression expression)
5632 {
5633 IType type = GetExpressionType(expression);
5634 if (type == TypeSystemServices.BoolType) return expression;
5635 if (IsNumber(type)) return expression;
5636 if (type.IsEnum) return expression;
5637
5638 IMethod method = TypeSystemServices.FindImplicitConversionOperator(type, TypeSystemServices.BoolType);
5639 if (null != method) return CodeBuilder.CreateMethodInvocation(method, expression);
5640
5641 // reference types can be used in bool context
5642 if (!type.IsValueType) return expression;
5643
5644 Error(CompilerErrorFactory.BoolExpressionRequired(expression, type.ToString()));
5645 return expression;
5646 }
5647
5648 ReferenceExpression CreateTempLocal(LexicalInfo li, IType type)
5649 {
5650 InternalLocal local = DeclareTempLocal(type);
5651 ReferenceExpression reference = new ReferenceExpression(li, local.Name);
5652 reference.Entity = local;
5653 reference.ExpressionType = type;
5654 return reference;
5655 }
5656
5657 protected InternalLocal DeclareTempLocal(IType localType)
5658 {
5659 return CodeBuilder.DeclareTempLocal(_currentMethod.Method, localType);
5660 }
5661
5662 IEntity DeclareLocal(Node sourceNode, string name, IType localType)
5663 {
5664 return DeclareLocal(sourceNode, name, localType, false);
5665 }
5666
5667 virtual protected IEntity DeclareLocal(Node sourceNode, string name, IType localType, bool privateScope)
5668 {
5669 Local local = new Local(name, privateScope);
5670 local.LexicalInfo = sourceNode.LexicalInfo;
5671 InternalLocal entity = new InternalLocal(local, localType);
5672 local.Entity = entity;
5673 _currentMethod.Method.Locals.Add(local);
5674 return entity;
5675 }
5676
5677 protected IType CurrentType
5678 {
5679 get
5680 {
5681 return _currentMethod.DeclaringType;
5682 }
5683 }
5684
5685 void PushMember(TypeMember member)
5686 {
5687 _memberStack.Push(member);
5688 }
5689
5690 TypeMember CurrentMember
5691 {
5692 get
5693 {
5694 return (TypeMember)_memberStack.Peek();
5695 }
5696 }
5697
5698 void PopMember()
5699 {
5700 _memberStack.Pop();
5701 }
5702
5703 void PushMethodInfo(InternalMethod tag)
5704 {
5705 _methodStack.Push(_currentMethod);
5706
5707 _currentMethod = tag;
5708 }
5709
5710 void PopMethodInfo()
5711 {
5712 _currentMethod = (InternalMethod)_methodStack.Pop();
5713 }
5714
5715 void AssertHasSideEffect(Expression expression)
5716 {
5717 if (!HasSideEffect(expression) && !TypeSystemServices.IsError(expression))
5718 {
5719 Error(CompilerErrorFactory.ExpressionMustBeExecutedForItsSideEffects(expression));
5720 }
5721 }
5722
5723 protected virtual bool HasSideEffect(Expression node)
5724 {
5725 return
5726 node.NodeType == NodeType.MethodInvocationExpression ||
5727 AstUtil.IsAssignment(node) ||
5728 AstUtil.IsIncDec(node);
5729 }
5730
5731 bool AssertCanCreateInstance(Node sourceNode, IType type)
5732 {
5733 if (type.IsInterface)
5734 {
5735 Error(CompilerErrorFactory.CantCreateInstanceOfInterface(sourceNode, type.ToString()));
5736 return false;
5737 }
5738 if (type.IsEnum)
5739 {
5740 Error(CompilerErrorFactory.CantCreateInstanceOfEnum(sourceNode, type.ToString()));
5741 return false;
5742 }
5743 if (type.IsAbstract)
5744 {
5745 Error(CompilerErrorFactory.CantCreateInstanceOfAbstractType(sourceNode, type.ToString()));
5746 return false;
5747 }
5748 if (!(type is GenericConstructedType)
5749 &&
5750 ((type.GenericInfo != null
5751 && type.GenericInfo.GenericParameters.Length > 0)
5752 || (type.ConstructedInfo != null
5753 && !type.ConstructedInfo.FullyConstructed))
5754 )
5755 {
5756 Error(CompilerErrorFactory.GenericTypesMustBeConstructedToBeInstantiated(sourceNode));
5757 return false;
5758 }
5759 return true;
5760 }
5761
5762 bool AssertDeclarationName(Declaration d)
5763 {
5764 if (AssertIdentifierName(d, d.Name))
5765 {
5766 return AssertUniqueLocal(d);
5767 }
5768 return false;
5769 }
5770
5771 bool AssertUniqueLocal(Declaration d)
5772 {
5773 if (null == _currentMethod.ResolveLocal(d.Name) &&
5774 null == _currentMethod.ResolveParameter(d.Name))
5775 {
5776 return true;
5777 }
5778 Error(CompilerErrorFactory.LocalAlreadyExists(d, d.Name));
5779 return false;
5780 }
5781
5782 void GetDeclarationType(IType defaultDeclarationType, Declaration d)
5783 {
5784 if (null != d.Type)
5785 {
5786 Visit(d.Type);
5787 AssertTypeCompatibility(d, GetType(d.Type), defaultDeclarationType);
5788 }
5789 else
5790 {
5791 d.Type = CodeBuilder.CreateTypeReference(defaultDeclarationType);
5792 }
5793 }
5794
5795 void DeclareLocal(Declaration d, bool privateScope)
5796 {
5797 if (AssertIdentifierName(d, d.Name))
5798 {
5799 d.Entity = DeclareLocal(d, d.Name, GetType(d.Type), privateScope);
5800 }
5801 }
5802
5803 protected IType GetEnumeratorItemType(IType iteratorType)
5804 {
5805 return TypeSystemServices.GetEnumeratorItemType(iteratorType);
5806 }
5807
5808 protected void ProcessDeclarationsForIterator(DeclarationCollection declarations, IType iteratorType)
5809 {
5810 IType defaultDeclType = GetEnumeratorItemType(iteratorType);
5811 if (declarations.Count > 1)
5812 {
5813 // will enumerate (unpack) each item
5814 defaultDeclType = GetEnumeratorItemType(defaultDeclType);
5815 }
5816
5817 foreach (Declaration d in declarations)
5818 {
5819 ProcessDeclarationForIterator(d, defaultDeclType);
5820 }
5821 }
5822
5823 protected void ProcessDeclarationForIterator(Declaration d, IType defaultDeclType)
5824 {
5825 GetDeclarationType(defaultDeclType, d);
5826 DeclareLocal(d, true);
5827 }
5828
5829 protected virtual bool AssertLValue(Node node)
5830 {
5831 IEntity entity = node.Entity;
5832 if (null != entity) return AssertLValue(node, entity);
5833
5834 if (IsArraySlicing(node)) return true;
5835 Error(CompilerErrorFactory.LValueExpected(node));
5836 return false;
5837 }
5838
5839 protected virtual bool AssertLValue(Node node, IEntity entity)
5840 {
5841 if (null != entity)
5842 {
5843 switch (entity.EntityType)
5844 {
5845 case EntityType.Parameter:
5846 case EntityType.Local:
5847 {
5848 return true;
5849 }
5850
5851 case EntityType.Property:
5852 {
5853 if (null == ((IProperty)entity).GetSetMethod())
5854 {
5855 Error(CompilerErrorFactory.PropertyIsReadOnly(AstUtil.GetMemberAnchor(node), entity.FullName));
5856 return false;
5857 }
5858 return true;
5859 }
5860
5861 case EntityType.Field:
5862 {
5863 IField fld = (IField)entity;
5864 if (TypeSystemServices.IsReadOnlyField(fld)
5865 && !(EntityType.Constructor == _currentMethod.EntityType
5866 && _currentMethod.DeclaringType == fld.DeclaringType
5867 && fld.IsStatic == _currentMethod.IsStatic))
5868 {
5869 Error(CompilerErrorFactory.FieldIsReadonly(AstUtil.GetMemberAnchor(node), entity.FullName));
5870 return false;
5871 }
5872 return true;
5873 }
5874 }
5875 }
5876 Error(CompilerErrorFactory.LValueExpected(node));
5877 return false;
5878 }
5879
5880 public static bool IsArraySlicing(Node node)
5881 {
5882 if (node.NodeType != NodeType.SlicingExpression) return false;
5883 IType type = ((SlicingExpression)node).Target.ExpressionType;
5884 return null != type && type.IsArray;
5885 }
5886
5887 bool IsStandaloneReference(Node node)
5888 {
5889 Node parent = node.ParentNode;
5890 if (parent is GenericReferenceExpression)
5891 {
5892 parent = parent.ParentNode;
5893 }
5894
5895 return parent.NodeType != NodeType.MemberReferenceExpression;
5896 }
5897
5898 string GetSignature(IEnumerable args)
5899 {
5900 StringBuilder sb = new StringBuilder("(");
5901 foreach (Expression arg in args)
5902 {
5903 if (sb.Length > 1)
5904 {
5905 sb.Append(", ");
5906 }
5907 if (AstUtil.IsExplodeExpression(arg))
5908 {
5909 sb.Append('*');
5910 }
5911 sb.Append(GetExpressionType(arg));
5912 }
5913 sb.Append(")");
5914 return sb.ToString();
5915 }
5916
5917 void InvalidOperatorForType(UnaryExpression node)
5918 {
5919 Error(node, CompilerErrorFactory.InvalidOperatorForType(node,
5920 GetUnaryOperatorText(node.Operator),
5921 GetExpressionType(node.Operand).ToString()));
5922 }
5923
5924 void InvalidOperatorForTypes(BinaryExpression node)
5925 {
5926 Error(node, CompilerErrorFactory.InvalidOperatorForTypes(node,
5927 GetBinaryOperatorText(node.Operator),
5928 GetExpressionType(node.Left).ToString(),
5929 GetExpressionType(node.Right).ToString()));
5930 }
5931
5932 void TraceReturnType(Method method, IMethod tag)
5933 {
5934 _context.TraceInfo("{0}: return type for method {1} bound to {2}", method.LexicalInfo, method.Name, tag.ReturnType);
5935 }
5936
5937 #region Method bindings cache
5938
5939 IMethod _RuntimeServices_Len;
5940
5941 IMethod RuntimeServices_Len
5942 {
5943 get
5944 {
5945 if (null == _RuntimeServices_Len)
5946 {
5947 _RuntimeServices_Len = ResolveMethod(TypeSystemServices.RuntimeServicesType, "Len");
5948 }
5949 return _RuntimeServices_Len;
5950 }
5951 }
5952
5953 IMethod _RuntimeServices_Mid;
5954
5955 IMethod RuntimeServices_Mid
5956 {
5957 get
5958 {
5959 if (null == _RuntimeServices_Mid)
5960 {
5961 _RuntimeServices_Mid = ResolveMethod(TypeSystemServices.RuntimeServicesType, "Mid");
5962 }
5963 return _RuntimeServices_Mid;
5964 }
5965 }
5966
5967 IMethod _RuntimeServices_NormalizeStringIndex;
5968
5969 IMethod RuntimeServices_NormalizeStringIndex
5970 {
5971 get
5972 {
5973 if (null == _RuntimeServices_NormalizeStringIndex)
5974 {
5975 _RuntimeServices_NormalizeStringIndex = ResolveMethod(TypeSystemServices.RuntimeServicesType, "NormalizeStringIndex");
5976 }
5977 return _RuntimeServices_NormalizeStringIndex;
5978 }
5979 }
5980
5981 IMethod _RuntimeServices_AddArrays;
5982
5983 IMethod RuntimeServices_AddArrays
5984 {
5985 get
5986 {
5987 if (null == _RuntimeServices_AddArrays)
5988 {
5989 _RuntimeServices_AddArrays = ResolveMethod(TypeSystemServices.RuntimeServicesType, "AddArrays");
5990 }
5991 return _RuntimeServices_AddArrays;
5992 }
5993 }
5994
5995 IMethod _RuntimeServices_GetRange1;
5996
5997 IMethod RuntimeServices_GetRange1
5998 {
5999 get
6000 {
6001 if (null == _RuntimeServices_GetRange1)
6002 {
6003 _RuntimeServices_GetRange1 = ResolveMethod(TypeSystemServices.RuntimeServicesType, "GetRange1");
6004 }
6005 return _RuntimeServices_GetRange1;
6006 }
6007 }
6008
6009 IMethod _RuntimeServices_GetRange2;
6010
6011 IMethod RuntimeServices_GetRange2
6012 {
6013 get
6014 {
6015 if (null == _RuntimeServices_GetRange2)
6016 {
6017 _RuntimeServices_GetRange2 = ResolveMethod(TypeSystemServices.RuntimeServicesType, "GetRange2");
6018 }
6019 return _RuntimeServices_GetRange2;
6020 }
6021 }
6022
6023 IMethod _RuntimeServices_GetMultiDimensionalRange1;
6024
6025 IMethod RuntimeServices_GetMultiDimensionalRange1
6026 {
6027 get
6028 {
6029 if (null == _RuntimeServices_GetMultiDimensionalRange1)
6030 {
6031 _RuntimeServices_GetMultiDimensionalRange1 = ResolveMethod(TypeSystemServices.RuntimeServicesType, "GetMultiDimensionalRange1");
6032 }
6033 return _RuntimeServices_GetMultiDimensionalRange1;
6034 }
6035 }
6036
6037 IMethod _RuntimeServices_SetMultiDimensionalRange1;
6038
6039 IMethod RuntimeServices_SetMultiDimensionalRange1
6040 {
6041 get
6042 {
6043 if (null == _RuntimeServices_SetMultiDimensionalRange1)
6044 {
6045 _RuntimeServices_SetMultiDimensionalRange1 = ResolveMethod(TypeSystemServices.RuntimeServicesType, "SetMultiDimensionalRange1");
6046 }
6047 return _RuntimeServices_SetMultiDimensionalRange1;
6048 }
6049 }
6050
6051 IMethod _RuntimeServices_GetEnumerable;
6052
6053 IMethod RuntimeServices_GetEnumerable
6054 {
6055 get
6056 {
6057 if (null == _RuntimeServices_GetEnumerable)
6058 {
6059 _RuntimeServices_GetEnumerable = ResolveMethod(TypeSystemServices.RuntimeServicesType, "GetEnumerable");
6060 }
6061 return _RuntimeServices_GetEnumerable;
6062 }
6063 }
6064
6065 IMethod _RuntimeServices_EqualityOperator;
6066
6067 IMethod RuntimeServices_EqualityOperator
6068 {
6069 get
6070 {
6071 if (null == _RuntimeServices_EqualityOperator)
6072 {
6073 _RuntimeServices_EqualityOperator = TypeSystemServices.Map(Types.RuntimeServices.GetMethod("EqualityOperator", new Type[] { Types.Object, Types.Object }));
6074 }
6075 return _RuntimeServices_EqualityOperator;
6076 }
6077 }
6078
6079 IMethod _Array_get_Length;
6080
6081 IMethod Array_get_Length
6082 {
6083 get
6084 {
6085 if (null == _Array_get_Length)
6086 {
6087 _Array_get_Length = ResolveProperty(TypeSystemServices.ArrayType, "Length").GetGetMethod();
6088 }
6089 return _Array_get_Length;
6090 }
6091 }
6092
6093 IMethod _Array_GetLength;
6094
6095 IMethod Array_GetLength
6096 {
6097 get
6098 {
6099 if (null == _Array_GetLength)
6100 {
6101 _Array_GetLength = ResolveMethod(TypeSystemServices.ArrayType, "GetLength");
6102 }
6103 return _Array_GetLength;
6104 }
6105 }
6106
6107 IMethod _String_get_Length;
6108
6109 IMethod String_get_Length
6110 {
6111 get
6112 {
6113 if (null == _String_get_Length)
6114 {
6115 _String_get_Length = ResolveProperty(TypeSystemServices.StringType, "Length").GetGetMethod();
6116 }
6117 return _String_get_Length;
6118 }
6119 }
6120
6121 IMethod _String_Substring_Int;
6122
6123 IMethod String_Substring_Int
6124 {
6125 get
6126 {
6127 if (null == _String_Substring_Int)
6128 {
6129 _String_Substring_Int = TypeSystemServices.Map(Types.String.GetMethod("Substring", new Type[] { Types.Int }));
6130 }
6131 return _String_Substring_Int;
6132 }
6133 }
6134
6135 IMethod _ICollection_get_Count;
6136
6137 IMethod ICollection_get_Count
6138 {
6139 get
6140 {
6141 if (null == _ICollection_get_Count)
6142 {
6143 _ICollection_get_Count = ResolveProperty(TypeSystemServices.ICollectionType, "Count").GetGetMethod();
6144 }
6145 return _ICollection_get_Count;
6146 }
6147 }
6148
6149 IMethod _List_GetRange1;
6150
6151 IMethod List_GetRange1
6152 {
6153 get
6154 {
6155 if (null == _List_GetRange1)
6156 {
6157 _List_GetRange1 = TypeSystemServices.Map(Types.List.GetMethod("GetRange", new Type[] { typeof(int) }));
6158 }
6159 return _List_GetRange1;
6160 }
6161 }
6162
6163 IMethod _List_GetRange2;
6164
6165 IMethod List_GetRange2
6166 {
6167 get
6168 {
6169 if (null == _List_GetRange2)
6170 {
6171 _List_GetRange2 = TypeSystemServices.Map(Types.List.GetMethod("GetRange", new Type[] { typeof(int), typeof(int) }));
6172 }
6173 return _List_GetRange2;
6174 }
6175 }
6176
6177 IMethod _ICallable_Call;
6178
6179 IMethod ICallable_Call
6180 {
6181 get
6182 {
6183 if (null == _ICallable_Call)
6184 {
6185 _ICallable_Call = ResolveMethod(TypeSystemServices.ICallableType, "Call");
6186 }
6187 return _ICallable_Call;
6188 }
6189 }
6190
6191 IMethod _Activator_CreateInstance;
6192
6193 IMethod Activator_CreateInstance
6194 {
6195 get
6196 {
6197 if (null == _Activator_CreateInstance)
6198 {
6199 _Activator_CreateInstance = TypeSystemServices.Map(typeof(Activator).GetMethod("CreateInstance", new Type[] { Types.Type, Types.ObjectArray }));
6200 }
6201 return _Activator_CreateInstance;
6202 }
6203 }
6204
6205 IConstructor _Exception_StringConstructor;
6206
6207 IConstructor Exception_StringConstructor
6208 {
6209 get
6210 {
6211 if (null == _Exception_StringConstructor)
6212 {
6213 _Exception_StringConstructor =
6214 TypeSystemServices.Map(
6215 Types.Exception.GetConstructor(new Type[] { typeof(string) }));
6216 }
6217 return _Exception_StringConstructor;
6218 }
6219 }
6220
6221 IMethod _TextReaderEnumerator_lines;
6222
6223 IMethod TextReaderEnumerator_lines
6224 {
6225 get
6226 {
6227 if (null == _TextReaderEnumerator_lines)
6228 {
6229 _TextReaderEnumerator_lines = TypeSystemServices.Map(typeof(TextReaderEnumerator).GetMethod("lines"));
6230 }
6231 return _TextReaderEnumerator_lines;
6232 }
6233 }
6234
6235 public bool OptimizeNullComparisons
6236 {
6237 get { return _optimizeNullComparisons; }
6238 set { _optimizeNullComparisons = value; }
6239 }
6240
6241 #endregion
6242 }
6243 }
Boo Programming Language