public void Build(DeclarationSyntax declaration, ContainerBinder containingScope)
{
declaration.Match()
.With<NamespaceSyntax>(@namespace =>
{
var imports = @namespace.UsingDirectives.SelectMany(u => GatherImportedSymbols(u, containingScope));
var namesCount = @namespace.Names.Count;
for(var i = 0; i < namesCount; i++)
{
var name = @namespace.Names[i];
var last = i == namesCount - 1;
var reference = containingScope.GetMembers(name.ValueText).OfType<NamespaceReference>().Single();
containingScope = new NamespaceBinder(containingScope, reference, last ? imports : Enumerable.Empty<ImportedSymbol>());
// The innermost binder is the one that has the imports and should be associated with the syntax node
if(last)
binders.Add(@namespace, containingScope);
}
foreach(var member in @namespace.Members)
Build(member, containingScope);
})
.With<ClassSyntax>(@class =>
{
var scope = new ClassBinder(containingScope, @class);
binders.Add(@class, scope);
foreach(var member in @class.Members)
Build(member, scope);
})
.With<FunctionSyntax>(function =>
{
foreach(var parameter in function.Parameters)
Build(parameter.Type.Type, containingScope);
// TODO deal with return type
Binder scope = new FunctionBinder(containingScope);
binders.Add(function, scope);
foreach(var statement in function.Body)
scope = Build(statement, scope);
})
// .With<VariableDeclaration>(global =>
// {
// global.Type.BindNames(scope);
// global.InitExpression?.BindNames(scope);
// })
.Exhaustive();
}
private void Build(ClassMemberSyntax member, ClassBinder containingScope)
{
member.Match()
.With<FieldSyntax>(field =>
{
Build(field.Type.Type, containingScope);
if(field.InitExpression != null)
Build(field.InitExpression, containingScope);
})
.With<ConstructorSyntax>(constructor =>
{
foreach(var parameter in constructor.Parameters)
Build(parameter.Type.Type, containingScope);
Binder scope = new FunctionBinder(containingScope);
binders.Add(constructor, scope);
foreach(var statement in constructor.Body)
scope = Build(statement, scope);
})
.With<DestructorSyntax>(destructor =>
{
foreach(var parameter in destructor.Parameters)
if(parameter.Type != null)
Build(parameter.Type.Type, containingScope);
Binder scope = new FunctionBinder(containingScope);
binders.Add(destructor, scope);
foreach(var statement in destructor.Body)
scope = Build(statement, scope);
})
.With<IndexerMethodSyntax>(indexer =>
{
foreach(var parameter in indexer.Parameters)
if(parameter.Type != null)
Build(parameter.Type.Type, containingScope);
// TODO deal with return type
Binder scope = new FunctionBinder(containingScope);
binders.Add(indexer, scope);
foreach(var statement in indexer.Body)
scope = Build(statement, scope);
})
.With<MethodSyntax>(method =>
{
foreach(var parameter in method.Parameters)
if(parameter.Type != null)
Build(parameter.Type.Type, containingScope);
// TODO deal with return type
Binder scope = new FunctionBinder(containingScope);
binders.Add(method, scope);
foreach(var statement in method.Body)
scope = Build(statement, scope);
})
.Exhaustive();
}