private IEnumerable <INamespace> ImportedNamespaces() { foreach (Import import in _module.Imports) { yield return((INamespace)TypeSystemServices.GetEntity(import)); } }
public IEntity GetDefaultMember() { IType defaultMemberAttribute = _typeSystemServices.Map(typeof(DefaultMemberAttribute)); foreach (Attribute attribute in _typeDefinition.Attributes) { IConstructor tag = TypeSystemServices.GetEntity(attribute) as IConstructor; if (null != tag) { if (defaultMemberAttribute == tag.DeclaringType) { StringLiteralExpression memberName = attribute.Arguments[0] as StringLiteralExpression; if (null != memberName) { List buffer = new List(); Resolve(buffer, memberName.Value, EntityType.Any); return(NameResolutionService.GetEntityFromList(buffer)); } } } } if (null != BaseType) { return(BaseType.GetDefaultMember()); } return(null); }
/// <summary> /// Checks if a specified type argument violates the constraints /// declared on a specified type paramter. /// </summary> public bool ViolatesParameterConstraints(IGenericParameter parameter, TypeReference argumentNode) { IType argument = TypeSystemServices.GetEntity(argumentNode) as IType; // Ensure argument is a valid type if (argument == null || TypeSystemServices.IsError(argument)) { return(false); } bool valid = true; // Check type semantics constraints if (parameter.IsClass && !argument.IsClass) { Errors.Add(CompilerErrorFactory.GenericArgumentMustBeReferenceType(ConstructionNode, parameter, argument)); valid = false; } if (parameter.IsValueType && !argument.IsValueType) { Errors.Add(CompilerErrorFactory.GenericArgumentMustBeValueType(argumentNode, parameter, argument)); valid = false; } // Check for default constructor if (parameter.MustHaveDefaultConstructor && !HasDefaultConstructor(argument)) { Errors.Add(CompilerErrorFactory.GenericArgumentMustHaveDefaultConstructor(argumentNode, parameter, argument)); valid = false; } // Check base type constraints IType[] baseTypes = parameter.GetTypeConstraints(); if (baseTypes != null) { foreach (IType baseType in baseTypes) { // Don't check for System.ValueType supertype constraint // if parameter also has explicit value type constraint if (baseType == _tss.ValueTypeType && parameter.IsValueType) { continue; } if (!baseType.IsAssignableFrom(argument)) { Errors.Add(CompilerErrorFactory.GenericArgumentMustHaveBaseType(argumentNode, parameter, argument, baseType)); valid = false; } } } return(!valid); }
public IMethod GetSetMethod() { if (null != _property.Setter) { return((IMethod)TypeSystemServices.GetEntity(_property.Setter)); } if (null != _override) { return(_override.GetSetMethod()); } return(null); }
private static bool IsOfType(Ast.Attribute attribute, IType attributeType) { var entity = TypeSystemServices.GetEntity(attribute); if (entity == attributeType) { return(true); } var constructor = entity as IConstructor; return(constructor != null && constructor.DeclaringType == attributeType); }
public bool Resolve(List targetList, string name, EntityType flags) { Declaration found = _declarations[name]; if (null != found) { IEntity element = TypeSystemServices.GetEntity(found); if (NameResolutionService.IsFlagSet(flags, element.EntityType)) { targetList.Add(element); return(true); } } return(false); }
override public IConstructor[] GetConstructors() { if (null == _constructors) { List constructors = new List(); foreach (TypeMember member in _typeDefinition.Members) { if (member.NodeType == NodeType.Constructor && !member.IsStatic) { constructors.Add(TypeSystemServices.GetEntity(member)); } } _constructors = (IConstructor[])constructors.ToArray(typeof(IConstructor)); } return(_constructors); }
public IEntity GetDefaultMember() { IType defaultMemberAttribute = _typeSystemServices.Map(Types.DefaultMemberAttribute); foreach (Attribute attribute in _typeDefinition.Attributes) { IConstructor tag = TypeSystemServices.GetEntity(attribute) as IConstructor; if (null != tag) { if (defaultMemberAttribute == tag.DeclaringType) { StringLiteralExpression memberName = attribute.Arguments[0] as StringLiteralExpression; if (null != memberName) { List buffer = new List(); Resolve(buffer, memberName.Value, EntityType.Any); return(NameResolutionService.GetEntityFromList(buffer)); } } } } if (_typeDefinition.BaseTypes.Count > 0) { List buffer = new List(); foreach (TypeReference baseType in _typeDefinition.BaseTypes) { IType tag = TypeSystemServices.GetType(baseType); IEntity defaultMember = tag.GetDefaultMember(); if (defaultMember != null) { if (tag.IsInterface) { buffer.AddUnique(defaultMember); } else //non-interface base class trumps interfaces { return(defaultMember); } } } return(NameResolutionService.GetEntityFromList(buffer)); } return(null); }
public static bool IsAttributeDefined(TypeMember member, IType attributeType) { foreach (Boo.Lang.Compiler.Ast.Attribute attr in member.Attributes) { IEntity entity = TypeSystemServices.GetEntity(attr); if (entity == attributeType) { return(true); // pre bound attribute } IConstructor constructor = entity as IConstructor; if (null == constructor) { continue; } if (constructor.DeclaringType == attributeType) { return(true); } } return(false); }
public virtual bool Resolve(List targetList, string name, EntityType flags) { if (NameResolutionService.IsFlagSet(flags, EntityType.Local)) { Local local = ResolveLocal(name); if (null != local) { targetList.Add(TypeSystemServices.GetEntity(local)); return(true); } } if (NameResolutionService.IsFlagSet(flags, EntityType.Parameter)) { ParameterDeclaration parameter = ResolveParameter(name); if (null != parameter) { targetList.Add(TypeSystemServices.GetEntity(parameter)); return(true); } } return(false); }
public ReferenceExpression CreateReference(ParameterDeclaration parameter) { return(CreateReference((InternalParameter)TypeSystemServices.GetEntity(parameter))); }
public IMethod GetRaiseMethod() { return((IMethod)TypeSystemServices.GetEntity(_event.Raise)); }
public IMethod GetAddMethod() { return((IMethod)TypeSystemServices.GetEntity(_event.Add)); }