?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No significant changes. Adding a few more tests to the primitives test case and...
[boo.git] / src / Boo.Lang.Compiler / TypeSystem / TypeSystemServices.cs
blobf9dee851f0612d4524546071072defc930949767
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 namespace Boo.Lang.Compiler.TypeSystem
30 {
31 using System;
32 using System.Collections;
33 using System.Reflection;
34 using System.Text;
35 using Boo.Lang.Compiler.Ast;
36 using Attribute = Boo.Lang.Compiler.Ast.Attribute;
37 using Module = Boo.Lang.Compiler.Ast.Module;
38
39 public class TypeSystemServices
40 {
41 public DuckTypeImpl DuckType;
42
43 public ExternalType IQuackFuType;
44
45 public ExternalType ExceptionType;
46
47 public ExternalType ApplicationExceptionType;
48
49 public ExternalType MulticastDelegateType;
50
51 public ExternalType DelegateType;
52
53 public ExternalType IntPtrType;
54
55 public ExternalType UIntPtrType;
56
57 public ExternalType ObjectType;
58
59 public ExternalType ValueTypeType;
60
61 public ExternalType EnumType;
62
63 public ExternalType RegexType;
64
65 public ExternalType ArrayType;
66
67 public ExternalType TypeType;
68
69 public IArrayType ObjectArrayType;
70
71 public ExternalType VoidType;
72
73 public ExternalType StringType;
74
75 public ExternalType BoolType;
76
77 public ExternalType CharType;
78
79 public ExternalType SByteType;
80
81 public ExternalType ByteType;
82
83 public ExternalType ShortType;
84
85 public ExternalType UShortType;
86
87 public ExternalType IntType;
88
89 public ExternalType UIntType;
90
91 public ExternalType LongType;
92
93 public ExternalType ULongType;
94
95 public ExternalType SingleType;
96
97 public ExternalType DoubleType;
98
99 public ExternalType DecimalType;
100
101 public ExternalType TimeSpanType;
102
103 protected ExternalType DateTimeType;
104
105 public ExternalType RuntimeServicesType;
106
107 public ExternalType BuiltinsType;
108
109 public ExternalType ListType;
110
111 public ExternalType HashType;
112
113 public ExternalType ICallableType;
114
115 public ExternalType IEnumerableType;
116
117 public ExternalType IEnumeratorType;
118
119 public ExternalType IEnumerableGenericType;
120
121 public ExternalType IEnumeratorGenericType;
122
123 public ExternalType ICollectionType;
124
125 public ExternalType IListType;
126
127 public ExternalType IDictionaryType;
128
129 public ExternalType SystemAttribute;
130
131 public ExternalType ConditionalAttribute;
132
133 protected Hashtable _primitives = new Hashtable();
134
135 protected Hashtable _entityCache = new Hashtable();
136
137 protected Hashtable _arrayCache = new Hashtable();
138
139 public static readonly IType ErrorEntity = Error.Default;
140
141 public readonly BooCodeBuilder CodeBuilder;
142
143 private StringBuilder _buffer = new StringBuilder();
144
145 private Module _compilerGeneratedTypesModule;
146
147 private Module _compilerGeneratedExtensionsModule;
148
149 private ClassDefinition _compilerGeneratedExtensionsClass;
150
151 protected readonly CompilerContext _context;
152
153 private readonly AnonymousCallablesManager _anonymousCallablesManager;
154
155 private readonly GenericsServices _genericsServices;
156
157 public TypeSystemServices() : this(new CompilerContext())
158 {
159 }
160
161 public TypeSystemServices(CompilerContext context)
162 {
163 if (null == context) throw new ArgumentNullException("context");
164
165 _context = context;
166 _anonymousCallablesManager = new AnonymousCallablesManager(this);
167 _genericsServices = new GenericsServices(context);
168
169 CodeBuilder = new BooCodeBuilder(this);
170
171 Cache(typeof(Builtins.duck), DuckType = new DuckTypeImpl(this));
172 Cache(IQuackFuType = new ExternalType(this, typeof(IQuackFu)));
173 Cache(VoidType = new VoidTypeImpl(this));
174 Cache(ObjectType = new ExternalType(this, Types.Object));
175 Cache(RegexType = new ExternalType(this, Types.Regex));
176 Cache(ValueTypeType = new ExternalType(this, typeof(ValueType)));
177 Cache(EnumType = new ExternalType(this, typeof(Enum)));
178 Cache(ArrayType = new ExternalType(this, Types.Array));
179 Cache(TypeType = new ExternalType(this, Types.Type));
180 Cache(StringType = new ExternalType(this, Types.String));
181 Cache(BoolType = new ExternalType(this, Types.Bool));
182 Cache(SByteType = new ExternalType(this, Types.SByte));
183 Cache(CharType = new ExternalType(this, Types.Char));
184 Cache(ShortType = new ExternalType(this, Types.Short));
185 Cache(IntType = new ExternalType(this, Types.Int));
186 Cache(LongType = new ExternalType(this, Types.Long));
187 Cache(ByteType = new ExternalType(this, Types.Byte));
188 Cache(UShortType = new ExternalType(this, Types.UShort));
189 Cache(UIntType = new ExternalType(this, Types.UInt));
190 Cache(ULongType = new ExternalType(this, Types.ULong));
191 Cache(SingleType = new ExternalType(this, Types.Single));
192 Cache(DoubleType = new ExternalType(this, Types.Double));
193 Cache(DecimalType = new ExternalType(this, Types.Decimal));
194 Cache(TimeSpanType = new ExternalType(this, Types.TimeSpan));
195 Cache(DateTimeType = new ExternalType(this, Types.DateTime));
196 Cache(RuntimeServicesType = new ExternalType(this, Types.RuntimeServices));
197 Cache(BuiltinsType = new ExternalType(this, Types.Builtins));
198 Cache(ListType = new ExternalType(this, Types.List));
199 Cache(HashType = new ExternalType(this, Types.Hash));
200 Cache(ICallableType = new ExternalType(this, Types.ICallable));
201 Cache(IEnumerableType = new ExternalType(this, Types.IEnumerable));
202 Cache(IEnumeratorType = new ExternalType(this, typeof(IEnumerator)));
203 Cache(ICollectionType = new ExternalType(this, Types.ICollection));
204 Cache(IListType = new ExternalType(this, Types.IList));
205 Cache(IDictionaryType = new ExternalType(this, Types.IDictionary));
206 Cache(ApplicationExceptionType = new ExternalType(this, Types.ApplicationException));
207 Cache(ExceptionType = new ExternalType(this, Types.Exception));
208 Cache(IntPtrType = new ExternalType(this, Types.IntPtr));
209 Cache(UIntPtrType = new ExternalType(this, Types.UIntPtr));
210 Cache(MulticastDelegateType = new ExternalType(this, Types.MulticastDelegate));
211 Cache(DelegateType = new ExternalType(this, Types.Delegate));
212 Cache(SystemAttribute = new ExternalType(this, typeof(System.Attribute)));
213 Cache(ConditionalAttribute = new ExternalType(this, typeof(System.Diagnostics.ConditionalAttribute)));
214 Cache(IEnumerableGenericType = new ExternalType(this, typeof(System.Collections.Generic.IEnumerable<>)));
215 Cache(IEnumeratorGenericType = new ExternalType(this, typeof(System.Collections.Generic.IEnumerator<>)));
216
217 ObjectArrayType = GetArrayType(ObjectType, 1);
218
219 PreparePrimitives();
220 PrepareBuiltinFunctions();
221
222 }
223
224 public CompilerContext Context
225 {
226 get { return _context; }
227 }
228
229 public GenericsServices GenericsServices
230 {
231 get { return _genericsServices; }
232 }
233
234 public IType GetMostGenericType(IType current, IType candidate)
235 {
236 if (current.IsAssignableFrom(candidate))
237 {
238 return current;
239 }
240
241 if (candidate.IsAssignableFrom(current))
242 {
243 return candidate;
244 }
245
246 if (IsNumberOrBool(current) && IsNumberOrBool(candidate))
247 {
248 return GetPromotedNumberType(current, candidate);
249 }
250
251 if (IsCallableType(current) && IsCallableType(candidate))
252 {
253 return ICallableType;
254 }
255
256 if (current.IsClass && candidate.IsClass)
257 {
258 if (current == ObjectType || candidate == ObjectType)
259 {
260 return ObjectType;
261 }
262 if (current.GetTypeDepth() < candidate.GetTypeDepth())
263 {
264 return GetMostGenericType(current.BaseType, candidate);
265 }
266 return GetMostGenericType(current, candidate.BaseType);
267 }
268 return ObjectType;
269 }
270
271 public IType GetPromotedNumberType(IType left, IType right)
272 {
273 if (left == DecimalType ||
274 right == DecimalType)
275 {
276 return DecimalType;
277 }
278 if (left == DoubleType ||
279 right == DoubleType)
280 {
281 return DoubleType;
282 }
283 if (left == SingleType ||
284 right == SingleType)
285 {
286 return SingleType;
287 }
288 if (left == ULongType)
289 {
290 if (right == SByteType ||
291 right == ShortType ||
292 right == IntType ||
293 right == LongType)
294 {
295 // This is against the C# spec but allows expressions like:
296 // ulong x = 4
297 // y = x + 1
298 // y will be long.
299 // C# disallows mixing ulongs and signed numbers
300 // but in the above case it promotes the constant to ulong
301 // and the result is ulong.
302 // Since its too late here to promote the constant,
303 // maybe we should return LongType. I didn't chose ULongType
304 // because in other cases <unsigned> <op> <signed> returns <signed>.
305 return LongType;
306 }
307 return ULongType;
308 }
309 if (right == ULongType)
310 {
311 if (left == SByteType ||
312 left == ShortType ||
313 left == IntType ||
314 left == LongType)
315 {
316 // This is against the C# spec but allows expressions like:
317 // ulong x = 4
318 // y = 1 + x
319 // y will be long.
320 // C# disallows mixing ulongs and signed numbers
321 // but in the above case it promotes the constant to ulong
322 // and the result is ulong.
323 // Since its too late here to promote the constant,
324 // maybe we should return LongType. I didn't chose ULongType
325 // because in other cases <signed> <op> <unsigned> returns <signed>.
326 return LongType;
327 }
328 return ULongType;
329 }
330 if (left == LongType ||
331 right == LongType)
332 {
333 return LongType;
334 }
335 if (left == UIntType)
336 {
337 if (right == SByteType ||
338 right == ShortType ||
339 right == IntType)
340 {
341 // This is allowed per C# spec and y is long:
342 // uint x = 4
343 // y = x + 1
344 // C# promotes <uint> <op> <signed> to <long> also
345 // but in the above case it promotes the constant to uint first
346 // and the result of "x + 1" is uint.
347 // Since its too late here to promote the constant,
348 // "y = x + 1" will be long in boo.
349 return LongType;
350 }
351 return UIntType;
352 }
353 if (right == UIntType)
354 {
355 if (left == SByteType ||
356 left == ShortType ||
357 left == IntType)
358 {
359 // This is allowed per C# spec and y is long:
360 // uint x = 4
361 // y = 1 + x
362 // C# promotes <signed> <op> <uint> to <long> also
363 // but in the above case it promotes the constant to uint first
364 // and the result of "1 + x" is uint.
365 // Since its too late here to promote the constant,
366 // "y = x + 1" will be long in boo.
367 return LongType;
368 }
369 return UIntType;
370 }
371 if (left == IntType ||
372 right == IntType ||
373 left == ShortType ||
374 right == ShortType ||
375 left == UShortType ||
376 right == UShortType ||
377 left == ByteType ||
378 right == ByteType ||
379 left == SByteType ||
380 right == SByteType)
381 {
382 return IntType;
383 }
384 return left;
385 }
386
387 public static bool IsReadOnlyField(IField field)
388 {
389 return field.IsInitOnly || field.IsLiteral;
390 }
391
392 public bool IsCallable(IType type)
393 {
394 return (TypeType == type) || IsCallableType(type) || IsDuckType(type);
395 }
396
397 public virtual bool IsDuckTyped(Expression expression)
398 {
399 IType type = expression.ExpressionType;
400 return null != type && this.IsDuckType(type);
401 }
402
403 public bool IsQuackBuiltin(Expression node)
404 {
405 return IsQuackBuiltin(GetOptionalEntity(node));
406 }
407
408 public bool IsQuackBuiltin(IEntity entity)
409 {
410 return BuiltinFunction.Quack == entity;
411 }
412
413 public bool IsDuckType(IType type)
414 {
415 if (null == type)
416 {
417 throw new ArgumentNullException("type");
418 }
419 return (
420 (type == DuckType)
421 || KnowsQuackFu(type)
422 || (_context.Parameters.Ducky
423 && (type == ObjectType)));
424 }
425
426 public bool KnowsQuackFu(IType type)
427 {
428 return type.IsSubclassOf(IQuackFuType);
429 }
430
431 bool IsCallableType(IType type)
432 {
433 return (ICallableType.IsAssignableFrom(type)) || (type is ICallableType);
434 }
435
436 public AnonymousCallableType GetCallableType(IMethod method)
437 {
438 CallableSignature signature = new CallableSignature(method);
439 return GetCallableType(signature);
440 }
441
442 public AnonymousCallableType GetCallableType(CallableSignature signature)
443 {
444 return _anonymousCallablesManager.GetCallableType(signature);
445 }
446
447 public virtual IType GetConcreteCallableType(Node sourceNode, CallableSignature signature)
448 {
449 return _anonymousCallablesManager.GetConcreteCallableType(sourceNode, signature);
450 }
451
452 public virtual IType GetConcreteCallableType(Node sourceNode, AnonymousCallableType anonymousType)
453 {
454 return _anonymousCallablesManager.GetConcreteCallableType(sourceNode, anonymousType);
455 }
456
457 public IType GetEnumeratorItemType(IType iteratorType)
458 {
459 // Arrays are enumerators of their element type
460 if (iteratorType.IsArray) return iteratorType.GetElementType();
461
462 // String are enumerators of char
463 if (StringType == iteratorType) return CharType;
464
465 // Try to use an EnumerableItemType attribute
466 if (iteratorType.IsClass)
467 {
468 IType enumeratorItemType = GetEnumeratorItemTypeFromAttribute(iteratorType);
469 if (null != enumeratorItemType) return enumeratorItemType;
470 }
471
472 // Try to use a generic IEnumerable interface
473 IType genericItemType = GetGenericEnumerableItemType(iteratorType);
474 if (null != genericItemType) return genericItemType;
475
476 // If none of these work, the type is an enumerator of object
477 return ObjectType;
478 }
479
480 public IType GetExpressionType(Expression node)
481 {
482 IType type = node.ExpressionType;
483 if (null == type)
484 {
485 throw CompilerErrorFactory.InvalidNode(node);
486 }
487 return type;
488 }
489
490 public IType GetConcreteExpressionType(Expression expression)
491 {
492 IType type = GetExpressionType(expression);
493 AnonymousCallableType anonymousType = type as AnonymousCallableType;
494 if (null != anonymousType)
495 {
496 IType concreteType = GetConcreteCallableType(expression, anonymousType);
497 expression.ExpressionType = concreteType;
498 return concreteType;
499 }
500 return type;
501 }
502
503 public void MapToConcreteExpressionTypes(ExpressionCollection items)
504 {
505 foreach (Expression item in items)
506 {
507 GetConcreteExpressionType(item);
508 }
509 }
510
511 public ClassDefinition GetCompilerGeneratedExtensionsClass()
512 {
513 if (null == _compilerGeneratedExtensionsClass)
514 {
515 BooClassBuilder builder = CodeBuilder.CreateClass("CompilerGeneratedExtensions");
516 builder.Modifiers = TypeMemberModifiers.Final|TypeMemberModifiers.Transient|TypeMemberModifiers.Public;
517 builder.AddBaseType(ObjectType);
518
519 BooMethodBuilder ctor = builder.AddConstructor();
520 ctor.Modifiers = TypeMemberModifiers.Private;
521 ctor.Body.Add(
522 CodeBuilder.CreateSuperConstructorInvocation(ObjectType));
523
524 ClassDefinition cd = builder.ClassDefinition;
525 Module module = GetCompilerGeneratedExtensionsModule();
526 module.Members.Add(cd);
527 ((ModuleEntity)module.Entity).InitializeModuleClass(cd);
528
529 _compilerGeneratedExtensionsClass = cd;
530 }
531 return _compilerGeneratedExtensionsClass;
532 }
533
534 public Module GetCompilerGeneratedExtensionsModule()
535 {
536 if (null == _compilerGeneratedExtensionsModule)
537 {
538 _compilerGeneratedExtensionsModule = NewModule(null, "CompilerGeneratedExtensions");
539 }
540 return _compilerGeneratedExtensionsModule;
541 }
542
543 public void AddCompilerGeneratedType(TypeDefinition type)
544 {
545 GetCompilerGeneratedTypesModule().Members.Add(type);
546 }
547
548 public Module GetCompilerGeneratedTypesModule()
549 {
550 if (null == _compilerGeneratedTypesModule)
551 {
552 _compilerGeneratedTypesModule = NewModule("CompilerGenerated");
553 }
554 return _compilerGeneratedTypesModule;
555 }
556
557 private Module NewModule(string nameSpace)
558 {
559 return NewModule(nameSpace, nameSpace);
560 }
561
562 private Module NewModule(string nameSpace, string moduleName)
563 {
564 Module module = new Module();
565 module.Name = moduleName;
566 if (null != nameSpace) module.Namespace = new NamespaceDeclaration(nameSpace);
567 module.Entity = new ModuleEntity(_context.NameResolutionService, this, module);
568 _context.CompileUnit.Modules.Add(module);
569 return module;
570 }
571
572 public ClassDefinition CreateCallableDefinition(string name)
573 {
574 ClassDefinition cd = new ClassDefinition();
575 cd.IsSynthetic = true;
576 cd.BaseTypes.Add(CodeBuilder.CreateTypeReference(this.MulticastDelegateType));
577 cd.BaseTypes.Add(CodeBuilder.CreateTypeReference(this.ICallableType));
578 cd.Name = name;
579 cd.Modifiers = TypeMemberModifiers.Final;
580 cd.Members.Add(CreateCallableConstructor());
581 cd.Members.Add(CreateCallMethod());
582 cd.Entity = new InternalCallableType(this, cd);
583 return cd;
584 }
585
586 Method CreateCallMethod()
587 {
588 Method method = new Method("Call");
589 method.IsSynthetic = true;
590 method.Modifiers = TypeMemberModifiers.Public|TypeMemberModifiers.Virtual;
591 method.Parameters.Add(CodeBuilder.CreateParameterDeclaration(1, "args", ObjectArrayType));
592 method.ReturnType = CodeBuilder.CreateTypeReference(ObjectType);
593 method.Entity = new InternalMethod(this, method);
594 return method;
595 }
596
597 Constructor CreateCallableConstructor()
598 {
599 Constructor constructor = new Constructor();
600 constructor.IsSynthetic = true;
601 constructor.Modifiers = TypeMemberModifiers.Public;
602 constructor.ImplementationFlags = MethodImplementationFlags.Runtime;
603 constructor.Parameters.Add(
604 CodeBuilder.CreateParameterDeclaration(1, "instance", ObjectType));
605 constructor.Parameters.Add(
606 CodeBuilder.CreateParameterDeclaration(2, "method", IntPtrType));
607 constructor.Entity = new InternalConstructor(this, constructor);
608 return constructor;
609 }
610
611 public bool AreTypesRelated(IType lhs, IType rhs)
612 {
613 ICallableType ctype = lhs as ICallableType;
614 if (null != ctype)
615 {
616 return ctype.IsAssignableFrom(rhs)
617 || ctype.IsSubclassOf(rhs);
618 }
619
620 return lhs.IsAssignableFrom(rhs)
621 || (lhs.IsInterface && !rhs.IsFinal)
622 || (rhs.IsInterface && !lhs.IsFinal)
623 || CanBeReachedByDownCastOrPromotion(lhs, rhs)
624 || FindImplicitConversionOperator(rhs,lhs) != null;
625 }
626
627 public IMethod FindExplicitConversionOperator(IType fromType, IType toType)
628 {
629 return FindConversionOperator("op_Explicit", fromType, toType);
630 }
631
632 public IMethod FindImplicitConversionOperator(IType fromType, IType toType)
633 {
634 return FindConversionOperator("op_Implicit", fromType, toType);
635 }
636
637 public IMethod FindConversionOperator(string name, IType fromType, IType toType)
638 {
639 while (fromType != this.ObjectType)
640 {
641 IMethod method = FindConversionOperator(name, fromType, toType, fromType.GetMembers());
642 if (null != method) return method;
643 method = FindConversionOperator(name, fromType, toType, toType.GetMembers());
644 if (null != method) return method;
645 method = FindConversionOperator(name, fromType, toType, FindExtension(fromType, name));
646 if (null != method) return method;
647
648 fromType = fromType.BaseType;
649 if (null == fromType) break;
650 }
651 return null;
652 }
653
654 private IEntity[] FindExtension(IType fromType, string name)
655 {
656 IEntity extension = _context.NameResolutionService.ResolveExtension(fromType, name);
657 if (null == extension) return Ambiguous.NoEntities;
658
659 Ambiguous a = extension as Ambiguous;
660 if (null != a) return a.Entities;
661 return new IEntity[] { extension };
662 }
663
664 IMethod FindConversionOperator(string name, IType fromType, IType toType, IEntity[] candidates)
665 {
666 foreach (IEntity entity in candidates)
667 {
668 if (EntityType.Method != entity.EntityType || name != entity.Name) continue;
669 IMethod method = (IMethod)entity;
670 if (IsConversionOperator(method, fromType, toType)) return method;
671 }
672 return null;
673 }
674
675 bool IsConversionOperator(IMethod method, IType fromType, IType toType)
676 {
677 if (!method.IsStatic) return false;
678 if (method.ReturnType != toType) return false;
679 IParameter[] parameters = method.GetParameters();
680 return (1 == parameters.Length && fromType == parameters[0].Type);
681 }
682
683 public bool IsCallableTypeAssignableFrom(ICallableType lhs, IType rhs)
684 {
685 if (lhs == rhs) return true;
686 if (Null.Default == rhs) return true;
687
688 ICallableType other = rhs as ICallableType;
689 if (null == other) return false;
690
691 CallableSignature lvalue = lhs.GetSignature();
692 CallableSignature rvalue = other.GetSignature();
693 if (lvalue == rvalue) return true;
694
695 IParameter[] lparams = lvalue.Parameters;
696 IParameter[] rparams = rvalue.Parameters;
697 if (lparams.Length < rparams.Length) return false;
698
699 for (int i=0; i<rparams.Length; ++i)
700 {
701 if (!AreTypesRelated(lparams[i].Type, rparams[i].Type)) return false;
702 }
703
704 return CompatibleReturnTypes(lvalue, rvalue);
705 }
706
707 private bool CompatibleReturnTypes(CallableSignature lvalue, CallableSignature rvalue)
708 {
709 if (VoidType != lvalue.ReturnType && VoidType != rvalue.ReturnType)
710 {
711 return AreTypesRelated(lvalue.ReturnType, rvalue.ReturnType);
712 }
713
714 return true;
715 }
716
717 public static bool CheckOverrideSignature(IMethod impl, IMethod baseMethod)
718 {
719 return CheckOverrideSignature(impl.GetParameters(), baseMethod.GetParameters());
720 }
721
722 public static bool CheckOverrideSignature(IParameter[] implParameters, IParameter[] baseParameters)
723 {
724 if (implParameters.Length != baseParameters.Length) return false;
725
726 for (int i=0; i<implParameters.Length; ++i)
727 {
728 IParameter implParameter = implParameters[i];
729 IParameter baseParameter = baseParameters[i];
730 IType implType = implParameter.Type;
731 IType baseType = baseParameter.Type;
732
733 if (baseType.IsByRef)
734 {
735 if (!implParameter.IsByRef) return false;
736 if (baseType.GetElementType() != implType) return false;
737 }
738 else
739 {
740 if (implType != baseType) return false;
741 }
742 }
743 return true;
744 }
745
746 public virtual bool CanBeReachedByDownCastOrPromotion(IType expectedType, IType actualType)
747 {
748 return CanBeReachedByDowncast(expectedType, actualType)
749 || CanBeReachedByPromotion(expectedType, actualType);
750 }
751
752 public virtual bool CanBeReachedByDowncast(IType expectedType, IType actualType)
753 {
754 return actualType.IsAssignableFrom(expectedType);
755 }
756
757 public virtual bool CanBeReachedByPromotion(IType expectedType, IType actualType)
758 {
759 return (expectedType.IsValueType
760 && IsNumber(expectedType)
761 && IsNumber(actualType));
762 }
763
764 public bool CanBeExplicitlyCastToInteger(IType type)
765 {
766 return type.IsEnum || type == this.CharType;
767 }
768
769 public static bool ContainsMethodsOnly(List members)
770 {
771 foreach (IEntity member in members)
772 {
773 if (EntityType.Method != member.EntityType) return false;
774 }
775 return true;
776 }
777
778 public bool IsIntegerNumber(IType type)
779 {
780 return
781 type == this.ShortType ||
782 type == this.IntType ||
783 type == this.LongType ||
784 type == this.SByteType ||
785 type == this.UShortType ||
786 type == this.UIntType ||
787 type == this.ULongType ||
788 type == this.ByteType;
789 }
790
791 public bool IsIntegerOrBool(IType type)
792 {
793 return BoolType == type || IsIntegerNumber(type);
794 }
795
796 public bool IsNumberOrBool(IType type)
797 {
798 return BoolType == type || IsNumber(type);
799 }
800
801 public bool IsNumber(IType type)
802 {
803 return
804 IsPrimitiveNumber(type) ||
805 type == this.DecimalType;
806 }
807
808 public bool IsPrimitiveNumber(IType type)
809 {
810 return
811 IsIntegerNumber(type) ||
812 type == this.DoubleType ||
813 type == this.SingleType;
814 }
815
816 public static bool IsUnknown(Expression node)
817 {
818 IType type = node.ExpressionType;
819 if (null != type)
820 {
821 return IsUnknown(type);
822 }
823 return false;
824 }
825
826 public static bool IsUnknown(IType tag)
827 {
828 return EntityType.Unknown == tag.EntityType;
829 }
830
831 public static bool IsError(Expression node)
832 {
833 IType type = node.ExpressionType;
834 if (null != type)
835 {
836 return IsError(type);
837 }
838 return false;
839 }
840
841 public static bool IsErrorAny(ExpressionCollection collection)
842 {
843 foreach (Expression n in collection)
844 {
845 if (IsError(n))
846 {
847 return true;
848 }
849 }
850 return false;
851 }
852
853 public bool IsBuiltin(IEntity tag)
854 {
855 if (EntityType.Method == tag.EntityType)
856 {
857 return BuiltinsType == ((IMethod)tag).DeclaringType;
858 }
859 return false;
860 }
861
862 public static bool IsError(IEntity tag)
863 {
864 return EntityType.Error == tag.EntityType;
865 }
866
867 public static TypeMemberModifiers GetAccess(IAccessibleMember member)
868 {
869 if (member.IsPublic)
870 {
871 return TypeMemberModifiers.Public;
872 }
873 else if (member.IsProtected)
874 {
875 return TypeMemberModifiers.Protected;
876 }
877 return TypeMemberModifiers.Private;
878 }
879
880 public static IEntity[] GetAllMembers(INamespace entity)
881 {
882 List members = new List();
883 GetAllMembers(members, entity);
884 return (IEntity[])members.ToArray(new IEntity[members.Count]);
885 }
886
887 private static void GetAllMembers(List members, INamespace entity)
888 {
889 if (null == entity) return;
890
891 IType type = entity as IType;
892 if (null != type)
893 {
894 members.ExtendUnique(type.GetMembers());
895 GetAllMembers(members, type.BaseType);
896 }
897 else
898 {
899 members.Extend(entity.GetMembers());
900 }
901 }
902
903 static object EntityAnnotationKey = new object();
904
905 public static void Bind(Node node, IEntity entity)
906 {
907 if (null == node) throw new ArgumentNullException("node");
908 node[EntityAnnotationKey] = entity;
909 }
910
911 public static IEntity GetOptionalEntity(Node node)
912 {
913 if (null == node) throw new ArgumentNullException("node");
914 return (IEntity)node[EntityAnnotationKey];
915 }
916
917 public static IEntity GetEntity(Node node)
918 {
919 IEntity tag = GetOptionalEntity(node);
920 if (null == tag) InvalidNode(node);
921
922 return tag;
923 }
924
925 public static IType GetReferencedType(Expression typeref)
926 {
927 switch (typeref.NodeType)
928 {
929 case NodeType.TypeofExpression:
930 {
931 return GetType(((TypeofExpression)typeref).Type);
932 }
933 case NodeType.ReferenceExpression:
934 case NodeType.MemberReferenceExpression:
935 case NodeType.GenericReferenceExpression:
936 {
937 return typeref.Entity as IType;
938 }
939 }
940 return null;
941 }
942
943 public virtual bool IsModule(Type type)
944 {
945 return type.IsClass
946 && type.IsSealed
947 && !type.IsNestedPublic
948 && MetadataUtil.IsAttributeDefined(type, Types.ModuleAttribute);
949 }
950
951 public bool IsAttribute(IType type)
952 {
953 return type.IsSubclassOf(SystemAttribute);
954 }
955
956 public static IType GetType(Node node)
957 {
958 return ((ITypedEntity)GetEntity(node)).Type;
959 }
960
961 public IType Map(Type type)
962 {
963 ExternalType entity = (ExternalType)_entityCache[type];
964 if (null == entity)
965 {
966 if (type.IsArray) return GetArrayType(Map(type.GetElementType()), type.GetArrayRank());
967 entity = CreateEntityForType(type);
968 Cache(entity);
969 }
970 return entity;
971 }
972
973 private ExternalType CreateEntityForType(Type type)
974 {
975 if (type.IsGenericParameter) return new ExternalGenericParameter(this, type);
976 if (type.IsSubclassOf(Types.MulticastDelegate)) return new ExternalCallableType(this, type);
977 return new ExternalType(this, type);
978 }
979
980 public IArrayType GetArrayType(IType elementType, int rank)
981 {
982 ArrayHash key = new ArrayHash(elementType, rank);
983 IArrayType entity = (IArrayType)_arrayCache[key];
984 if (null == entity)
985 {
986 entity = new ArrayType(this, elementType, rank);
987 _arrayCache.Add(key, entity);
988 }
989 return entity;
990 }
991
992 protected class ArrayHash
993 {
994 IType _type;
995 int _rank;
996
997 public ArrayHash(IType elementType, int rank)
998 {
999 _type = elementType;
1000 _rank = rank;
1001 }
1002
1003 public override int GetHashCode()
1004 {
1005 return _type.GetHashCode() ^ _rank;
1006 }
1007
1008 public override bool Equals(object obj)
1009 {
1010 return ((ArrayHash)obj)._type == _type && ((ArrayHash)obj)._rank == _rank;
1011 }
1012 }
1013
1014 public IParameter[] Map(ParameterDeclarationCollection parameters)
1015 {
1016 IParameter[] mapped = new IParameter[parameters.Count];
1017 for (int i=0; i<mapped.Length; ++i)
1018 {
1019 mapped[i] = (IParameter)GetEntity(parameters[i]);
1020 }
1021 return mapped;
1022 }
1023
1024 public IParameter[] Map(ParameterInfo[] parameters)
1025 {
1026 IParameter[] mapped = new IParameter[parameters.Length];
1027 for (int i=0; i<parameters.Length; ++i)
1028 {
1029 mapped[i] = new ExternalParameter(this, parameters[i]);
1030 }
1031 return mapped;
1032 }
1033
1034 public IConstructor Map(ConstructorInfo constructor)
1035 {
1036 object key = GetCacheKey(constructor);
1037 IConstructor entity = (IConstructor)_entityCache[key];
1038 if (null == entity)
1039 {
1040 entity = new ExternalConstructor(this, constructor);
1041 _entityCache[key] = entity;
1042 }
1043 return entity;
1044 }
1045
1046 public IMethod Map(MethodInfo method)
1047 {
1048 object key = GetCacheKey(method);
1049 IMethod entity = (IMethod)_entityCache[key];
1050 if (null == entity)
1051 {
1052 entity = new ExternalMethod(this, method);
1053 _entityCache[key] = entity;
1054 }
1055 return entity;
1056 }
1057
1058 public IEntity Map(MemberInfo[] info)
1059 {
1060 if (info.Length > 1)
1061 {
1062 IEntity[] tags = new IEntity[info.Length];
1063 for (int i=0; i<tags.Length; ++i)
1064 {
1065 tags[i] = Map(info[i]);
1066 }
1067 return new Ambiguous(tags);
1068 }
1069 if (info.Length > 0)
1070 {
1071 return Map(info[0]);
1072 }
1073 return null;
1074 }
1075
1076 public IEntity Map(MemberInfo mi)
1077 {
1078 IEntity tag = (IEntity)_entityCache[GetCacheKey(mi)];
1079 if (null == tag)
1080 {
1081 switch (mi.MemberType)
1082 {
1083 case MemberTypes.Method:
1084 {
1085 return Map((MethodInfo)mi);
1086 }
1087
1088 case MemberTypes.Constructor:
1089 {
1090 return Map((ConstructorInfo)mi);
1091 }
1092
1093 case MemberTypes.Field:
1094 {
1095 tag = new ExternalField(this, (FieldInfo)mi);
1096 break;
1097 }
1098
1099 case MemberTypes.Property:
1100 {
1101 tag = new ExternalProperty(this, (PropertyInfo)mi);
1102 break;
1103 }
1104
1105 case MemberTypes.Event:
1106 {
1107 tag = new ExternalEvent(this, (EventInfo)mi);
1108 break;
1109 }
1110
1111 case MemberTypes.NestedType:
1112 {
1113 return Map((Type)mi);
1114 }
1115
1116 default:
1117 {
1118 throw new NotImplementedException(mi.ToString());
1119 }
1120 }
1121 _entityCache.Add(GetCacheKey(mi), tag);
1122 }
1123 return tag;
1124 }
1125
1126 public string GetSignature(IEntityWithParameters method)
1127 {
1128 return GetSignature(method, true);
1129 }
1130
1131 public string GetSignature(IEntityWithParameters method, bool includeFullName)
1132 {
1133 _buffer.Length = 0;
1134 if (includeFullName)
1135 {
1136 _buffer.Append(method.FullName);
1137 }
1138 else
1139 {
1140 _buffer.Append(method.Name);
1141 }
1142 _buffer.Append("(");
1143
1144 IParameter[] parameters = method.GetParameters();
1145 for (int i=0; i<parameters.Length; ++i)
1146 {
1147 if (i > 0) { _buffer.Append(", "); }
1148 if (method.AcceptVarArgs && i == parameters.Length-1) { _buffer.Append('*'); }
1149 _buffer.Append(parameters[i].Type);
1150 }
1151 _buffer.Append(")");
1152 return _buffer.ToString();
1153 }
1154
1155 public object GetCacheKey(MemberInfo mi)
1156 {
1157 return mi;
1158 }
1159
1160 public IEntity ResolvePrimitive(string name)
1161 {
1162 return (IEntity)_primitives[name];
1163 }
1164
1165 public bool IsPrimitive(string name)
1166 {
1167 return _primitives.ContainsKey(name);
1168 }
1169
1170 /// <summary>
1171 /// checks if the passed type will be equivalente to
1172 /// System.Object in runtime (accounting for the presence
1173 /// of duck typing).
1174 /// </summary>
1175 public bool IsSystemObject(IType type)
1176 {
1177 return type == ObjectType || type == DuckType;
1178 }
1179
1180 public bool RequiresBoxing(IType expectedType, IType actualType)
1181 {
1182 if (!actualType.IsValueType) return false;
1183 return IsSystemObject(expectedType);
1184 }
1185
1186 protected virtual void PreparePrimitives()
1187 {
1188 AddPrimitiveType("duck", DuckType);
1189 AddPrimitiveType("void", VoidType);
1190 AddPrimitiveType("object", ObjectType);
1191 AddPrimitiveType("bool", BoolType);
1192 AddPrimitiveType("sbyte", SByteType);
1193 AddPrimitiveType("byte", ByteType);
1194 AddPrimitiveType("short", ShortType);
1195 AddPrimitiveType("ushort", UShortType);
1196 AddPrimitiveType("int", IntType);
1197 AddPrimitiveType("uint", UIntType);
1198 AddPrimitiveType("long", LongType);
1199 AddPrimitiveType("ulong", ULongType);
1200 AddPrimitiveType("single", SingleType);
1201 AddPrimitiveType("double", DoubleType);
1202 AddPrimitiveType("decimal", DecimalType);
1203 AddPrimitiveType("char", CharType);
1204 AddPrimitiveType("string", StringType);
1205 AddPrimitiveType("regex", RegexType);
1206 AddPrimitiveType("date", DateTimeType);
1207 AddPrimitiveType("timespan", TimeSpanType);
1208 AddPrimitiveType("callable", ICallableType);
1209 }
1210
1211 protected virtual void PrepareBuiltinFunctions()
1212 {
1213 AddBuiltin(BuiltinFunction.Len);
1214 AddBuiltin(BuiltinFunction.AddressOf);
1215 AddBuiltin(BuiltinFunction.Eval);
1216 AddBuiltin(BuiltinFunction.Switch);
1217 }
1218
1219 protected void AddPrimitiveType(string name, ExternalType type)
1220 {
1221 _primitives[name] = type;
1222 type.PrimitiveName = name;
1223 }
1224
1225 protected void AddBuiltin(BuiltinFunction function)
1226 {
1227 _primitives[function.Name] = function;
1228 }
1229
1230 void Cache(ExternalType tag)
1231 {
1232 _entityCache[tag.ActualType] = tag;
1233 }
1234
1235 void Cache(object key, IType tag)
1236 {
1237 _entityCache[key] = tag;
1238 }
1239
1240 public IConstructor GetDefaultConstructor(IType type)
1241 {
1242 IConstructor[] constructors = type.GetConstructors();
1243 for (int i=0; i<constructors.Length; ++i)
1244 {
1245 IConstructor constructor = constructors[i];
1246 if (0 == constructor.GetParameters().Length)
1247 {
1248 return constructor;
1249 }
1250 }
1251 return null;
1252 }
1253
1254 IType GetExternalEnumeratorItemType(IType iteratorType)
1255 {
1256 Type type = ((ExternalType)iteratorType).ActualType;
1257 EnumeratorItemTypeAttribute attribute = (EnumeratorItemTypeAttribute)System.Attribute.GetCustomAttribute(type, typeof(EnumeratorItemTypeAttribute));
1258 if (null != attribute)
1259 {
1260 return Map(attribute.ItemType);
1261 }
1262 return null;
1263 }
1264
1265 IType GetEnumeratorItemTypeFromAttribute(IType iteratorType)
1266 {
1267 // If iterator type is external get its attributes via reflection
1268 if (iteratorType is ExternalType)
1269 {
1270 return GetExternalEnumeratorItemType(iteratorType);
1271 }
1272
1273 // If iterator type is a generic constructed type, map its attribute from its definition
1274 GenericConstructedType constructedType = iteratorType as GenericConstructedType;
1275 if (constructedType != null)
1276 {
1277 return constructedType.GenericMapping.Map(
1278 GetEnumeratorItemTypeFromAttribute(constructedType.GenericDefinition));
1279 }
1280
1281 // If iterator type is internal get its attributes from its type definition
1282 AbstractInternalType internalType = (AbstractInternalType)iteratorType;
1283 IType enumeratorItemTypeAttribute = Map(typeof(EnumeratorItemTypeAttribute));
1284 foreach (Attribute attribute in internalType.TypeDefinition.Attributes)
1285 {
1286 IConstructor constructor = GetEntity(attribute) as IConstructor;
1287 if (null != constructor)
1288 {
1289 if (constructor.DeclaringType == enumeratorItemTypeAttribute)
1290 {
1291 return GetType(attribute.Arguments[0]);
1292 }
1293 }
1294 }
1295 return null;
1296 }
1297
1298 public IType GetGenericEnumerableItemType(IType iteratorType)
1299 {
1300 // Arrays implicitly implement IEnumerable[of element type]
1301 if (iteratorType is ArrayType) return iteratorType.GetElementType();
1302
1303 // If type is not an array, try to find IEnumerable[of some type] in its interfaces
1304 IType itemType = null;
1305 foreach (IType type in GenericsServices.FindConstructedTypes(iteratorType, IEnumerableGenericType))
1306 {
1307 IType candidateItemType = type.ConstructedInfo.GenericArguments[0];
1308
1309 if (itemType != null)
1310 {
1311 itemType = GetMostGenericType(itemType, candidateItemType);
1312 }
1313 else
1314 {
1315 itemType = candidateItemType;
1316 }
1317 }
1318
1319 return itemType;
1320 }
1321
1322 public IEntity GetMemberEntity(TypeMember member)
1323 {
1324 if (null == member.Entity)
1325 {
1326 member.Entity = CreateEntity(member);
1327 }
1328 return member.Entity;
1329 }
1330
1331 private IEntity CreateEntity(TypeMember member)
1332 {
1333 switch (member.NodeType)
1334 {
1335 case NodeType.ClassDefinition:
1336 return new InternalClass(this, (TypeDefinition) member);
1337 case NodeType.Field:
1338 return new InternalField((Field)member);
1339 case NodeType.EnumMember:
1340 return new InternalEnumMember(this, (EnumMember)member);
1341 case NodeType.Method:
1342 return new InternalMethod(this, (Method)member);
1343 case NodeType.Constructor:
1344 return new InternalConstructor(this, (Constructor)member);
1345 case NodeType.Property:
1346 return new InternalProperty(this, (Property)member);
1347 case NodeType.Event:
1348 return new InternalEvent(this, (Event)member);
1349 }
1350 throw new ArgumentException("Member type not supported: " + member);
1351 }
1352
1353
1354 private static void InvalidNode(Node node)
1355 {
1356 throw CompilerErrorFactory.InvalidNode(node);
1357 }
1358
1359 public class DuckTypeImpl : ExternalType
1360 {
1361 public DuckTypeImpl(TypeSystemServices typeSystemServices) :
1362 base(typeSystemServices, Types.Object)
1363 {
1364 }
1365 }
1366
1367 #region VoidTypeImpl
1368 class VoidTypeImpl : ExternalType
1369 {
1370 internal VoidTypeImpl(TypeSystemServices typeSystemServices) : base(typeSystemServices, Types.Void)
1371 {
1372 }
1373
1374 override public bool Resolve(List targetList, string name, EntityType flags)
1375 {
1376 return false;
1377 }
1378
1379 override public bool IsSubclassOf(IType other)
1380 {
1381 return false;
1382 }
1383
1384 override public bool IsAssignableFrom(IType other)
1385 {
1386 return false;
1387 }
1388 }
1389
1390 #endregion
1391 }
1392 }
Boo Programming Language