void OrganizeNamespaces()
{
foreach (Assembly asm in CompilerParameters.References)
{
Type[] types = asm.GetTypes();
foreach (Type type in types)
{
string ns = type.Namespace;
if (null == ns)
{
ns = string.Empty;
}
string[] namespaceHierarchy = ns.Split('.');
string topLevelName = namespaceHierarchy[0];
Bindings.NamespaceBinding topLevel = GetNamespaceBinding(topLevelName);
Bindings.NamespaceBinding current = topLevel;
for (int i = 1; i < namespaceHierarchy.Length; ++i)
{
current = current.GetChildNamespace(namespaceHierarchy[i]);
// Trace(current);
}
current.Add(type);
List typeList = GetList(_externalTypes, type.FullName);
typeList.Add(type);
}
}
}
void Initialize()
{
Type type = typeof(AsyncResult);
_asyncResultType = TypeSystemServices.Map(type);
_asyncResultTypeAsyncDelegateGetter = TypeSystemServices.Map(Methods.GetterOf<AsyncResult, object>(r => r.AsyncDelegate));
_adaptors = new Boo.Lang.List();
}
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;
}
}
override public void Dispose()
{
_asyncResultType = null;
_asyncResultTypeAsyncDelegateGetter = null;
_adaptors = null;
base.Dispose();
}
public override void Dispose()
{
_asyncResultType = null;
_asyncResultTypeAsyncDelegateGetter = null;
_adaptors = null;
base.Dispose();
}
public bool ResolveMember(Boo.Lang.List targetList, string name, EntityType flags)
{
if (ResolveModuleMember(targetList, name, flags))
{
return(true);
}
return(_moduleClassNamespace.Resolve(targetList, name, flags));
}
override public void Run()
{
_newAbstractClasses = new List();
_classDefinitionList = new Hash();
Visit(CompileUnit.Modules);
_classDefinitionList.Clear();
ProcessNewAbstractClasses();
}
void Initialize()
{
Type type = typeof(AsyncResult);
_asyncResultType = TypeSystemServices.Map(type);
_asyncResultTypeAsyncDelegateGetter = TypeSystemServices.Map(Methods.GetterOf <AsyncResult, object>(r => r.AsyncDelegate));
_adaptors = new Boo.Lang.List();
}
void Initialize()
{
Type type = typeof(System.Runtime.Remoting.Messaging.AsyncResult);
_asyncResultType = TypeSystemServices.Map(type);
_asyncResultTypeAsyncDelegateGetter = TypeSystemServices.Map(type.GetProperty("AsyncDelegate").GetGetMethod());
_adaptors = new Boo.Lang.List();
}
List GetList(Hashtable hash, string key)
{
List list = (List)hash[key];
if (null == list)
{
list = new List();
hash[key] = list;
}
return(list);
}
private void CheckParameterUniqueness(Method method)
{
Boo.Lang.List parameters = new Boo.Lang.List();
foreach (ParameterDeclaration parameter in method.Parameters)
{
if (parameters.Contains(parameter.Name))
{
Errors.Add(CompilerErrorFactory.DuplicateParameterName(parameter, parameter.Name, method.Name));
}
parameters.Add(parameter.Name);
}
}
private void CheckParameterUniqueness(Method method)
{
Boo.Lang.List parameters = new Boo.Lang.List();
foreach (ParameterDeclaration parameter in method.Parameters)
{
if (parameters.Contains(parameter.Name))
{
Errors.Add(
CompilerErrorFactory.DuplicateParameterName(
parameter, parameter.Name, GetEntity(method).ToString()));
}
parameters.Add(parameter.Name);
}
}
public bool Resolve(Boo.Lang.List targetList, string name, EntityType flags)
{
if (ResolveMember(targetList, name, flags))
{
return(true);
}
bool found = false;
foreach (INamespace ns in ImportedNamespaces())
{
found |= ns.Resolve(targetList, name, flags);
}
return(found);
}
bool ResolveModuleMember(Boo.Lang.List targetList, string name, EntityType flags)
{
bool found = false;
foreach (Boo.Lang.Compiler.Ast.TypeMember member in _module.Members)
{
if (name == member.Name)
{
IEntity tag = TypeSystemServices.GetEntity(member);
if (NameResolutionService.IsFlagSet(flags, tag.EntityType))
{
targetList.Add(tag);
found = true;
}
}
}
return(found);
}
void ResolveBaseTypes(Boo.Lang.List visited, TypeDefinition node)
{
// If type is generic, enter a special namespace to allow
// correct resolution of generic parameters
IType type = (IType)TypeSystemServices.GetEntity(node);
if (type.GenericInfo != null)
{
EnterNamespace(new GenericParametersNamespaceExtender(
type, NameResolutionService.CurrentNamespace));
}
visited.Add(node);
int removed = 0;
int index = 0;
foreach (SimpleTypeReference baseType in node.BaseTypes.ToArray())
{
NameResolutionService.ResolveSimpleTypeReference(baseType);
AbstractInternalType internalType = baseType.Entity as AbstractInternalType;
if (null != internalType)
{
if (visited.Contains(internalType.TypeDefinition))
{
Error(CompilerErrorFactory.InheritanceCycle(baseType, internalType.FullName));
node.BaseTypes.RemoveAt(index - removed);
++removed;
}
else
{
ResolveBaseTypes(visited, internalType.TypeDefinition);
}
}
++index;
}
// Leave special namespace if we entered it before
if (type.GenericInfo != null)
{
LeaveNamespace();
}
}
bool ResolveModuleMember(Boo.Lang.List targetList, string name, EntityType flags)
{
bool found = false;
foreach (TypeMember member in _module.Members)
{
if (name != member.Name)
{
continue;
}
IEntity entity = _typeSystemServices.GetMemberEntity(member);
if (NameResolutionService.IsFlagSet(flags, entity.EntityType))
{
targetList.Add(entity);
found = true;
}
}
return(found);
}
public bool Resolve(Boo.Lang.List targetList, string name, EntityType flags)
{
if (ResolveMember(targetList, name, flags))
{
return(true);
}
if (null == _using)
{
_using = new INamespace[_module.Imports.Count];
for (int i = 0; i < _using.Length; ++i)
{
_using[i] = (INamespace)TypeSystemServices.GetEntity(_module.Imports[i]);
}
}
bool found = false;
foreach (INamespace ns in _using)
{
found |= ns.Resolve(targetList, name, flags);
}
return(found);
}
override public void Dispose()
{
_newAbstractClasses = null;
base.Dispose();
}
internal ExceptionHandlerCollection(Boo.Lang.Compiler.Ast.Node parent, Boo.Lang.List list) : base(parent, list)
{
}
internal AttributeCollection(Boo.Lang.Compiler.Ast.Node parent, Boo.Lang.List list) : base(parent, list)
{
}
internal WhenClauseCollection(Boo.Lang.Compiler.Ast.Node parent, Boo.Lang.List list) : base(parent, list)
{
}
public void delegate_will_be_called_if_one_of_the_values_are_contained_even_if_invalid_case()
{
var list = new Boo.Lang.List(new[] { "google", "fOO" });
dsl.Call_when_message_contains_one_of(list, () => was_called = true);
was_called.ShouldBeTrue();
}
void Initialize()
{
Type type = typeof(System.Runtime.Remoting.Messaging.AsyncResult);
_asyncResultType = TypeSystemServices.Map(type);
_asyncResultTypeAsyncDelegateGetter = TypeSystemServices.Map(type.GetProperty("AsyncDelegate").GetGetMethod());
_adaptors = new Boo.Lang.List();
}
public void delegate_should_not_be_called_when_only_some_words_match()
{
var list = new Boo.Lang.List(new[] { "Some", "smoogle" });
dsl.Call_when_message_contains_all_of(list, () => was_called = true);
was_called.ShouldBeFalse();
}
public GenericParameterDeclarationCollection(Boo.Lang.Compiler.Ast.Node parent, Boo.Lang.List list) : base(parent, list)
{
}
internal TypeReferenceCollection(Boo.Lang.Compiler.Ast.Node parent, Boo.Lang.List list) : base(parent, list)
{
}
public override void Run()
{
_newAbstractClasses = new List();
_classDefinitionList = new Hash();
Visit(CompileUnit.Modules);
_classDefinitionList.Clear();
ProcessNewAbstractClasses();
}
private void Run()
{
IType type = (IType)TypeSystemServices.GetEntity(_typeDefinition);
EnterGenericParametersNamespace(type);
Boo.Lang.List visitedNonInterfaces = null;
Boo.Lang.List visitedInterfaces = null;
if (_typeDefinition is InterfaceDefinition)
{
visitedInterfaces = _visited;
// interfaces won't have noninterface base types so visitedNonInterfaces not necessary here
}
else
{
visitedNonInterfaces = _visited;
visitedInterfaces = new Boo.Lang.List();
}
foreach (SimpleTypeReference baseTypeRef in _typeDefinition.BaseTypes.ToArray())
{
NameResolutionService.ResolveSimpleTypeReference(baseTypeRef);
++_index;
AbstractInternalType baseType = baseTypeRef.Entity as AbstractInternalType;
if (null == baseType)
continue;
if (IsEnclosingType(baseType.TypeDefinition))
{
BaseTypeError(CompilerErrorFactory.NestedTypeCannotExtendEnclosingType(baseTypeRef, _typeDefinition.FullName, baseType.FullName));
continue;
}
if (baseType is InternalInterface)
CheckForCycles(baseTypeRef, baseType, visitedInterfaces);
else
CheckForCycles(baseTypeRef, baseType, visitedNonInterfaces);
}
LeaveGenericParametersNamespace(type);
}
void ResolveBaseTypes(Boo.Lang.List visited, TypeDefinition node)
{
// If type is generic, enter a special namespace to allow
// correct resolution of generic parameters
IType type = (IType)TypeSystemServices.GetEntity(node);
if (type.GenericInfo != null)
{
EnterNamespace(new GenericParametersNamespaceExtender(
type, NameResolutionService.CurrentNamespace));
}
visited.Add(node);
Boo.Lang.List visitedNonInterfaces = null;
Boo.Lang.List visitedInterfaces = null;
if (node is InterfaceDefinition)
{
visitedInterfaces = visited;
// interfaces won't have noninterface base types so visitedNonInterfaces not necessary here
}
else
{
visitedNonInterfaces = visited;
visitedInterfaces = new Boo.Lang.List();
}
int removed = 0;
int index = 0;
foreach (SimpleTypeReference baseType in node.BaseTypes.ToArray())
{
NameResolutionService.ResolveSimpleTypeReference(baseType);
AbstractInternalType internalType = baseType.Entity as AbstractInternalType;
if (null != internalType)
{
if (internalType is InternalInterface)
{
if (visitedInterfaces.Contains(internalType.TypeDefinition))
{
Error(CompilerErrorFactory.InheritanceCycle(baseType, internalType.FullName));
node.BaseTypes.RemoveAt(index - removed);
++removed;
}
else
{
ResolveBaseTypes(visitedInterfaces, internalType.TypeDefinition);
}
}
else
{
if (visitedNonInterfaces.Contains(internalType.TypeDefinition))
{
Error(CompilerErrorFactory.InheritanceCycle(baseType, internalType.FullName));
node.BaseTypes.RemoveAt(index - removed);
++removed;
}
else
{
ResolveBaseTypes(visitedNonInterfaces, internalType.TypeDefinition);
}
}
}
++index;
}
// Leave special namespace if we entered it before
if (type.GenericInfo != null)
{
LeaveNamespace();
}
}
public CompilerPipeline()
{
_items = new Boo.Lang.List();
_breakOnErrors = true;
}
internal StatementCollection(Boo.Lang.Compiler.Ast.Node parent, Boo.Lang.List list) : base(parent, list)
{
}
internal TypeDefinitionCollection(Boo.Lang.Compiler.Ast.Node parent, Boo.Lang.List list) : base(parent, list)
{
}
public CompilerPipeline()
{
_items = new Boo.Lang.List();
_breakOnErrors = true;
}
public virtual bool Resolve(Boo.Lang.List targetList, string name, EntityType flags)
{
return(false);
}
internal ExpressionCollection(Boo.Lang.Compiler.Ast.Node parent, Boo.Lang.List list) : base(parent, list)
{
}
public void delegate_will_not_be_called_if_none_of_the_values_are_contained()
{
var list = new Boo.Lang.List(new[] { "google", "smoogle" });
dsl.Call_when_message_contains_one_of(list, () => was_called = true);
was_called.ShouldBeFalse();
}
public override void Dispose()
{
_newAbstractClasses = null;
base.Dispose();
}
public void delegate_should_be_called_when_all_words_match()
{
var list = new Boo.Lang.List(new[] { "Some", "FOOBAR" });
dsl.Call_when_message_contains_all_of(list, () => was_called = true);
was_called.ShouldBeTrue();
}
protected override void When()
{
var two_options = new Boo.Lang.List(new[] { "A", "B" });
dsl.Call_reply_with_one_of(two_options);
}
override public void Run()
{
_newAbstractClasses = new List();
Visit(CompileUnit.Modules);
ProcessNewAbstractClasses();
}
