public override void OnReferenceExpression(ReferenceExpression node)
{
IEntity entity = NameResolutionService.Resolve(node.Name);
if (entity != null)
{
base.OnReferenceExpression(node);
return;
}
if (node.Name.StartsWith("@"))
{
string refComponentName = node.Name.Substring(1);
StringLiteralExpression literal = CodeBuilder.CreateStringLiteral(refComponentName);
ExternalConstructor constructor =
new ExternalConstructor(TypeSystemServices, _componentReferenceConstructor);
MethodInvocationExpression invocation = CodeBuilder.CreateConstructorInvocation(constructor, literal);
node.ParentNode.Replace(node, invocation);
return;
}
else if (node.ParentNode is MethodInvocationExpression)
{
MethodInvocationExpression mie = (MethodInvocationExpression)node.ParentNode;
//Transform the first parameter of Component ctor to string.
if (mie.Target.ToString() == "Component")
{
StringLiteralExpression literal = CodeBuilder.CreateStringLiteral(node.Name);
mie.Replace(node, literal);
return;
}
}
base.OnReferenceExpression(node);
}
void OrganizeExternalNamespaces()
{
foreach (Assembly asm in Parameters.References)
{
try
{
NameResolutionService.OrganizeAssemblyTypes(asm);
}
catch (ReflectionTypeLoadException x)
{
System.IO.StringWriter loadErrors = new System.IO.StringWriter();
loadErrors.Write("'" + asm.FullName + "' - (" + GetLocation(asm) + "):");
loadErrors.WriteLine(x.Message);
foreach (Exception e in x.LoaderExceptions)
{
loadErrors.WriteLine(e.Message);
}
Errors.Add(
CompilerErrorFactory.FailedToLoadTypesFromAssembly(
loadErrors.ToString(), x));
}
catch (Exception x)
{
Errors.Add(
CompilerErrorFactory.FailedToLoadTypesFromAssembly(
"'" + asm.FullName + "' - (" + GetLocation(asm) + "): " + x.Message, x));
}
}
}
override public void Run()
{
NameResolutionService.Reset();
Visit(CompileUnit.Modules);
BindAllParameters();
BindAllEvents();
}
/// <summary>
/// This turn a call to TryGetParemeter('item') where item is a local variable
/// into a WrapIfNull(item) method call.
/// </summary>
/// <param name="node">The node.</param>
public override void OnMethodInvocationExpression(MethodInvocationExpression node)
{
var expression = node.Target as ReferenceExpression;
if (expression == null || expression.Name != "TryGetParameter")
{
base.OnMethodInvocationExpression(node);
return;
}
var name = ((StringLiteralExpression)node.Arguments[0]).Value;
var entity = NameResolutionService.Resolve(name);
if (entity == null)
{
base.OnMethodInvocationExpression(node);
return;
}
var parentNode = node.ParentNode;
var mie = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateSelfReference(_currentMethod.DeclaringType),
wrapNullValue);
var item = new ReferenceExpression(node.LexicalInfo, name);
TypeSystemServices.Bind(item, entity);
mie.Arguments.Add(item);
parentNode.Replace(node, mie);
}
private bool TryAutoAddAssemblyReference(Boo.Lang.Compiler.Ast.Import import)
{
Assembly asm = Parameters.FindAssembly(import.Namespace);
if (asm != null)
{
return(false); //name resolution already failed earlier, don't try twice
}
asm = Parameters.LoadAssembly(import.Namespace, false);
if (asm == null)
{
return(false);
}
if (asm != null)
{
try
{
NameResolutionService.OrganizeAssemblyTypes(asm);
}
catch (Exception /*ignored*/)
{
return(false);
}
Parameters.AddAssembly(asm);
import.AssemblyReference = new ReferenceExpression(import.LexicalInfo, import.Namespace);
import.AssemblyReference.Entity = new AssemblyReference(asm);
return(true);
}
return(false);
}
void ResolveBaseTypes(Boo.Lang.List visited, TypeDefinition node)
{
visited.Add(node);
int removed = 0;
int index = 0;
foreach (SimpleTypeReference type in node.BaseTypes.ToArray())
{
NameResolutionService.ResolveSimpleTypeReference(type);
AbstractInternalType internalType = type.Entity as AbstractInternalType;
if (null != internalType)
{
if (visited.Contains(internalType.TypeDefinition))
{
Error(CompilerErrorFactory.InheritanceCycle(type, internalType.FullName));
node.BaseTypes.RemoveAt(index - removed);
++removed;
}
else
{
ResolveBaseTypes(visited, internalType.TypeDefinition);
}
}
++index;
}
}
private void CheckValidExtension(Method node)
{
var method = GetEntity(node);
if (!method.IsExtension)
{
return;
}
var extendedType = method.GetParameters()[0].Type;
var entity = NameResolutionService.Resolve(extendedType, method.Name, EntityType.Method);
if (entity == null)
{
return;
}
var conflicting = FindConflictingMember(method, entity);
if (conflicting == null || !conflicting.IsPublic)
{
return;
}
Error(CompilerErrorFactory.MemberNameConflict(node, extendedType, TypeSystemServices.GetSignature(conflicting)));
}
private void ReplaceMappedEntity(ReferenceExpression node, IType mappedType)
{
var entity = (IMember)node.Entity;
var targetType = _replacer.MapType(entity.DeclaringType);
node.Entity = NameResolutionService.ResolveMember(targetType, entity.Name, entity.EntityType);
}
private void BindAllParameters()
{
Method entryPoint = ContextAnnotations.GetEntryPoint(Context);
foreach (INodeWithParameters node in _parameters)
{
var member = (TypeMember)node;
if (member.ContainsAnnotation(PrivateMemberNeverUsed))
{
continue;
}
NameResolutionService.EnterNamespace((INamespace)TypeSystemServices.GetEntity(member.DeclaringType));
CodeBuilder.BindParameterDeclarations(member.IsStatic, node);
if (!member.IsVisible && !member.IsSynthetic)
{
IExplicitMember explicitMember = member as IExplicitMember;
if (null != explicitMember && null != explicitMember.ExplicitInfo)
{
continue;
}
if (member == entryPoint) //private Main is fine
{
continue;
}
member.Annotate(PrivateMemberNeverUsed, null);
}
}
}
private void CheckFieldInvocations()
{
var invocations = ContextAnnotations.GetFieldInvocations();
if (invocations == null)
{
return;
}
foreach (var node in invocations)
{
var et = node.Target.ExpressionType;
if (et is AnonymousCallableType)
{
et = ((AnonymousCallableType)et).ConcreteType;
node.Target.ExpressionType = et;
}
var invoke = NameResolutionService.Resolve(et, "Invoke") as IMethod;
if (invoke == null)
{
throw new System.NotSupportedException("Invoke method on callable field not found");
}
node.Target = CodeBuilder.CreateMemberReference(node.Target.LexicalInfo, node.Target, invoke);
}
}
private IEntity ResolveImportOnParentNamespace(Import import)
{
var current = NameResolutionService.CurrentNamespace;
INamespace parentNamespace = NameResolutionService.CurrentNamespace.ParentNamespace;
if (parentNamespace != null)
{
IEntity result;
if (!RetrieveCachedNamespace(parentNamespace, import.Namespace, out result))
{
NameResolutionService.EnterNamespace(parentNamespace);
try
{
result = NameResolutionService.ResolveQualifiedName(import.Namespace);
AddCachedNamespace(parentNamespace, import.Namespace, result);
}
finally
{
NameResolutionService.EnterNamespace(current);
}
}
return(result);
}
return(null);
}
private void LeaveGenericParametersNamespace(IType type)
{
if (type.GenericInfo != null)
{
NameResolutionService.LeaveNamespace();
}
}
IType GetExtendedMacroType(IMethod method)
{
InternalMethod internalMethod = method as InternalMethod;
if (null != internalMethod)
{
Method extension = internalMethod.Method;
if (!extension.Attributes.Contains(Types.CompilerGeneratedAttribute.FullName))
{
return(null);
}
SimpleTypeReference sref = extension.Parameters[0].Type as SimpleTypeReference;
if (null != sref && extension.Parameters.Count == 2)
{
IType type = NameResolutionService.ResolveQualifiedName(sref.Name) as IType;
if (type != null && type.Name.EndsWith("Macro")) //no entity yet
{
return(type);
}
}
}
else if (method is ExternalMethod && method.IsExtension)
{
var parameters = method.GetParameters();
if (parameters.Length == 2 && TypeSystemServices.IsMacro(parameters[0].Type))
{
return(parameters[0].Type);
}
}
return(null);
}
protected override bool ExpandExtension(ref MethodInvocationExpression extension,
MacroStatement macro, MacroStatement parent,
ref Statement expansion)
{
if (macro.Arguments.Count < 1)
{
AddMissingLifestyleTypeError(macro);
return(false);
}
ReferenceExpression lifestyle = macro.Arguments[0] as ReferenceExpression;
if (lifestyle == null)
{
AddMissingLifestyleTypeError(macro);
return(false);
}
macro.Arguments.RemoveAt(0);
IEntity entity = NameResolutionService.Resolve(lifestyle.Name);
if (entity == null || entity.EntityType != EntityType.Type)
{
AddMissingLifestyleTypeError(macro);
return(false);
}
Type lifestyleType = ((ExternalType)entity).ActualType;
return(InitializeLifestyleExtension(ref extension, lifestyle, lifestyleType) &&
ArgumentsToCreateNamedArguments(macro.Arguments, extension));
}
private void ReplaceWithComponentReference(Node node, string name)
{
Expression argument;
ConstructorInfo constructorInfo;
name = name.Substring(1);
var entity = NameResolutionService.ResolveQualifiedName(name);
if (node.ParentNode.NodeType == NodeType.GenericReferenceExpression)
{
var genericRef = (GenericReferenceExpression)(node = node.ParentNode);
entity = NameResolutionService.ResolveGenericReferenceExpression(genericRef, entity);
name = genericRef.ToCodeString();
}
if (entity == null || entity.EntityType != EntityType.Type)
{
constructorInfo = _componentReferenceConstructor;
argument = CodeBuilder.CreateStringLiteral(name);
}
else
{
constructorInfo = _componentReferenceTypeConstructor;
argument = CodeBuilder.CreateReference(entity);
}
var constructor = new ExternalConstructor(My <IReflectionTypeSystemProvider> .Instance, constructorInfo);
var invocation = CodeBuilder.CreateConstructorInvocation(constructor, argument);
node.ParentNode.Replace(node, invocation);
}
private void CheckValidExtension(Method node)
{
IMethod method = GetEntity(node);
if (!method.IsExtension)
{
return;
}
IType extendedType = method.GetParameters()[0].Type;
IEntity entity = NameResolutionService.Resolve(extendedType, method.Name, EntityType.Method);
if (null == entity)
{
return;
}
IMethod conflicting = FindConflictingMember(method, entity);
if (null == conflicting || !conflicting.IsPublic)
{
return;
}
Error(CompilerErrorFactory.MemberNameConflict(node, extendedType.ToString(), TypeSystemServices.GetSignature(conflicting, false)));
}
private void CreateEnumerator()
{
_enumerator = CodeBuilder.CreateClass("$Enumerator");
_enumerator.AddAttribute(CodeBuilder.CreateAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)));
_enumerator.Modifiers |= _enumerable.Modifiers;
_enumerator.LexicalInfo = this.LexicalInfo;
foreach (var param in _genericParams)
{
var replacement = _enumerator.AddGenericParameter(param.Name);
_methodToEnumeratorMapper.Replace((IType)param.Entity, (IType)replacement.Entity);
}
var abstractEnumeratorType =
TypeSystemServices.Map(typeof(GenericGeneratorEnumerator <>)).
GenericInfo.ConstructType(_methodToEnumeratorMapper.MapType(_generatorItemType));
_state = NameResolutionService.ResolveField(abstractEnumeratorType, "_state");
_yield = NameResolutionService.ResolveMethod(abstractEnumeratorType, "Yield");
_yieldDefault = NameResolutionService.ResolveMethod(abstractEnumeratorType, "YieldDefault");
_enumerator.AddBaseType(abstractEnumeratorType);
_enumerator.AddBaseType(TypeSystemServices.IEnumeratorType);
CreateEnumeratorConstructor();
CreateMoveNext();
_enumerable.ClassDefinition.Members.Add(_enumerator.ClassDefinition);
}
private INamespace SelectiveImportFor(INamespace ns, MethodInvocationExpression selectiveImportSpec)
{
var importedNames = selectiveImportSpec.Arguments;
var entities = new List <IEntity>(importedNames.Count);
var aliases = new Dictionary <string, string>(importedNames.Count);
foreach (Expression nameExpression in importedNames)
{
string name;
if (nameExpression is ReferenceExpression)
{
name = (nameExpression as ReferenceExpression).Name;
aliases[name] = name;
}
else
{
var tce = nameExpression as TryCastExpression;
var alias = (tce.Type as SimpleTypeReference).Name;
name = (tce.Target as ReferenceExpression).Name;
aliases[alias] = name;
// Remove the trycast expression, otherwise it gets processed in later steps
tce.Target.Annotate("alias", alias);
importedNames.Replace(nameExpression, tce.Target);
}
if (!ns.Resolve(entities, name, EntityType.Any))
{
Errors.Add(
CompilerErrorFactory.MemberNotFound(
nameExpression, name, ns, NameResolutionService.GetMostSimilarMemberName(ns, name, EntityType.Any)));
}
}
return(new SimpleNamespace(null, entities, aliases));
}
private void EnterGenericParametersNamespace(IType type)
{
if (type.GenericInfo != null)
{
NameResolutionService.EnterNamespace(new GenericParametersNamespaceExtender(
type, NameResolutionService.CurrentNamespace));
}
}
override public void Run()
{
NameResolutionService.Reset();
NameResolutionService.GlobalNamespace = new NamespaceDelegator(
NameResolutionService.GlobalNamespace,
SafeGetNamespace("Boo.Lang"),
TypeSystemServices.BuiltinsType);
}
void BindAllParameters()
{
foreach (INodeWithParameters node in _parameters)
{
TypeMember member = (TypeMember)node;
NameResolutionService.Restore((INamespace)TypeSystemServices.GetEntity(member.DeclaringType));
CodeBuilder.BindParameterDeclarations(member.IsStatic, node);
}
}
public bool Resolve(List targetList, string name, EntityType flags)
{
if (name == _alias && NameResolutionService.IsFlagSet(flags, _subject.EntityType))
{
targetList.Add(_subject);
return(true);
}
return(false);
}
protected Expression GetNameExpression(MacroStatement macro)
{
var referenceExpression = macro.Arguments[0] as ReferenceExpression;
return(referenceExpression != null &&
NameResolutionService.Resolve(referenceExpression.Name) == null
? CodeBuilder.CreateStringLiteral(referenceExpression.Name)
: macro.Arguments[0]);
}
private IEntity ResolveMacroName(MacroStatement node)
{
IEntity entity = NameResolutionService.ResolveQualifiedName(BuildMacroTypeName(node.Name));
if (null != entity)
{
return(entity);
}
return(NameResolutionService.ResolveQualifiedName(node.Name));
}
private IMethod ResolveMethod(IType type, string name)
{
IMethod method = NameResolutionService.ResolveMethod(type, name);
if (null == method)
{
throw new System.ArgumentException(string.Format("Method '{0}' not found in type '{1}'", type, name));
}
return(method);
}
private IEntity ResolvePreferringInternalMacros(string macroTypeName)
{
IEntity resolved = NameResolutionService.ResolveQualifiedName(macroTypeName);
Ambiguous ambiguous = resolved as Ambiguous;
if (null != ambiguous && ambiguous.AllEntitiesAre(EntityType.Type))
{
return(Entities.PreferInternalEntitiesOverExternalOnes(ambiguous));
}
return(resolved);
}
public void MyOutsideContext()
{
try
{
NameResolutionService service = My <NameResolutionService> .Instance;
Assert.Fail();
}
catch (InvalidOperationException)
{
}
}
override public void LeaveExceptionHandler(ExceptionHandler node)
{
if (null != node.Declaration.Type.Entity &&
((IType)node.Declaration.Type.Entity).FullName == "System.Exception" &&
!string.IsNullOrEmpty(node.Declaration.Name))
{
if (null != NameResolutionService.ResolveTypeName(new SimpleTypeReference(node.Declaration.Name)))
{
Warnings.Add(CompilerWarningFactory.AmbiguousExceptionName(node));
}
}
}
override public void Run()
{
NameResolutionService.Reset();
INamespace[] globals = new INamespace[2];
globals[0] = SafeGetNamespace((INamespace)NameResolutionService.ResolveQualifiedName("Boo.Lang"));
globals[1] = TypeSystemServices.BuiltinsType;
NameResolutionService.GlobalNamespace = new NamespaceDelegator(
NameResolutionService.GlobalNamespace,
globals);
}
Method CreateEventRaiseMethod(Event node, Field backingField)
{
TypeMemberModifiers modifiers = RemoveAccessiblityModifiers(node.Modifiers);
if (node.IsPrivate)
{
modifiers |= TypeMemberModifiers.Private;
}
else
{
modifiers |= TypeMemberModifiers.Protected | TypeMemberModifiers.Internal;
}
Method method = CodeBuilder.CreateMethod("raise_" + node.Name,
TypeSystemServices.VoidType,
modifiers);
ICallableType type = GetEntity(node.Type) as ICallableType;
if (null != type)
{
int index = CodeBuilder.GetFirstParameterIndex(node);
foreach (IParameter parameter in type.GetSignature().Parameters)
{
method.Parameters.Add(
CodeBuilder.CreateParameterDeclaration(
index,
parameter.Name,
parameter.Type,
parameter.IsByRef));
++index;
}
}
MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference(backingField),
NameResolutionService.ResolveMethod(GetType(backingField.Type), "Invoke"));
foreach (ParameterDeclaration parameter in method.Parameters)
{
mie.Arguments.Add(CodeBuilder.CreateReference(parameter));
}
IfStatement stmt = new IfStatement(node.LexicalInfo);
stmt.Condition = CodeBuilder.CreateNotNullTest(
CodeBuilder.CreateReference(backingField));
stmt.TrueBlock = new Block();
stmt.TrueBlock.Add(mie);
method.Body.Add(stmt);
return(method);
}
public CompileUnitNamespace(CompileUnit unit)
{
_nameResolutionService = My<NameResolutionService>.Instance;
_internalTypeSystemProvider = My<InternalTypeSystemProvider>.Instance;
_compileUnit = unit;
}
