private BoundNode BindTechniqueDeclaration(TechniqueSyntax declaration)
{
var techniqueSymbol = new TechniqueSymbol(declaration.Name.Text);
AddSymbol(techniqueSymbol, declaration.Name.Span);
var techniqueBinder = new Binder(_sharedBinderState, this);
var boundPasses = declaration.Passes.Select(x => techniqueBinder.Bind(x, techniqueBinder.BindPass));
return new BoundTechnique(techniqueSymbol, boundPasses.ToImmutableArray());
}
private BoundStatement BindSwitchStatement(SwitchStatementSyntax syntax, Symbol parent)
{
BindAttributes(syntax.Attributes);
var switchBinder = new Binder(_sharedBinderState, this);
var boundSections = syntax.Sections.Select(x => switchBinder.Bind(x, y => switchBinder.BindSwitchSection(y, parent))).ToImmutableArray();
return new BoundSwitchStatement(
Bind(syntax.Expression, BindExpression),
boundSections);
}
private BoundBlock BindBlock(BlockSyntax syntax, Symbol parent)
{
var blockBinder = new Binder(_sharedBinderState, this);
return new BoundBlock(syntax.Statements.Select(x => blockBinder.Bind(x, y => blockBinder.BindStatement(y, parent))).ToImmutableArray());
}
private BoundForStatement BindForStatement(ForStatementSyntax syntax, Symbol parent)
{
BindAttributes(syntax.Attributes);
var forStatementBinder = new Binder(_sharedBinderState, this);
// Note that we bind declarations in the current scope, not the for statement scope.
return new BoundForStatement(
syntax.Declaration != null ? Bind(syntax.Declaration, x => BindForStatementDeclaration(x, parent)) : null,
syntax.Initializer != null ? forStatementBinder.Bind(syntax.Initializer, forStatementBinder.BindExpression) : null,
forStatementBinder.Bind(syntax.Condition, forStatementBinder.BindExpression),
syntax.Incrementor != null ? forStatementBinder.Bind(syntax.Incrementor, forStatementBinder.BindExpression) : null,
forStatementBinder.Bind(syntax.Statement, x => forStatementBinder.BindStatement(x, parent)));
}
private BoundInterfaceType BindInterfaceDeclaration(InterfaceTypeSyntax declaration, Symbol parent)
{
var interfaceSymbol = new InterfaceSymbol(declaration, parent);
AddSymbol(interfaceSymbol, declaration.Name.Span);
var methods = new List<BoundFunction>();
var interfaceBinder = new Binder(_sharedBinderState, this);
foreach (var memberSyntax in declaration.Methods)
methods.Add(interfaceBinder.Bind(memberSyntax, x => interfaceBinder.BindFunctionDeclaration(x, interfaceSymbol)));
foreach (var member in interfaceBinder.LocalSymbols.Values.SelectMany(x => x))
interfaceSymbol.AddMember(member);
return new BoundInterfaceType(interfaceSymbol, methods.ToImmutableArray());
}
private BoundStructType BindStructDeclaration(StructTypeSyntax declaration, Symbol parent)
{
var structSymbol = new StructSymbol(declaration, parent);
AddSymbol(structSymbol, declaration.Name?.Span ?? declaration.GetTextSpanSafe());
var variables = new List<BoundMultipleVariableDeclarations>();
var structBinder = new Binder(_sharedBinderState, this);
foreach (var variableDeclarationStatement in declaration.Fields)
variables.Add(structBinder.Bind(variableDeclarationStatement, x => structBinder.BindField(x, structSymbol)));
foreach (var member in structBinder.LocalSymbols.Values.SelectMany(x => x))
structSymbol.AddMember(member);
return new BoundStructType(structSymbol, variables.ToImmutableArray());
}
private BoundClassType BindClassDeclaration(ClassTypeSyntax declaration, Symbol parent)
{
ClassSymbol baseClass = null;
var baseInterfaces = new List<InterfaceSymbol>();
if (declaration.BaseList != null)
{
var baseType = Bind(declaration.BaseList.BaseType, x => BindType(x, parent));
switch (baseType.TypeSymbol.Kind)
{
case SymbolKind.Class:
baseClass = (ClassSymbol) baseType.TypeSymbol;
break;
case SymbolKind.Interface:
baseInterfaces.Add((InterfaceSymbol) baseType.TypeSymbol);
break;
}
}
var classBinder = new Binder(_sharedBinderState, this);
var classSymbol = new ClassSymbol(declaration, parent, baseClass, baseInterfaces.ToImmutableArray(), classBinder);
AddSymbol(classSymbol, declaration.Name.Span);
var members = new List<BoundNode>();
foreach (var memberSyntax in declaration.Members)
{
switch (memberSyntax.Kind)
{
case SyntaxKind.VariableDeclarationStatement:
members.Add(classBinder.Bind((VariableDeclarationStatementSyntax) memberSyntax, x => classBinder.BindVariableDeclarationStatement(x, classSymbol)));
break;
case SyntaxKind.FunctionDeclaration:
members.Add(classBinder.Bind((FunctionDeclarationSyntax) memberSyntax, x => classBinder.BindFunctionDeclaration(x, classSymbol)));
break;
case SyntaxKind.FunctionDefinition:
members.Add(classBinder.Bind((FunctionDefinitionSyntax) memberSyntax, x => classBinder.BindFunctionDefinition(x, classSymbol)));
break;
}
}
foreach (var member in classBinder.LocalSymbols.Values.SelectMany(x => x))
classSymbol.AddMember(member);
return new BoundClassType(classSymbol, members.ToImmutableArray());
}
private ImmutableArray<BoundVariableDeclaration> BindParameters(ParameterListSyntax parameterList, Binder invocableBinder, InvocableSymbol invocableSymbol)
{
var boundParameters = new List<BoundVariableDeclaration>();
foreach (var parameterSyntax in parameterList.Parameters)
{
var parameterValueType = Bind(parameterSyntax.Type, x => BindType(x, null));
var parameterDirection = SyntaxFacts.GetParameterDirection(parameterSyntax.Modifiers);
boundParameters.Add(invocableBinder.Bind(parameterSyntax.Declarator, x => invocableBinder.BindVariableDeclarator(x, parameterValueType.TypeSymbol, (d, t) =>
new SourceParameterSymbol(
parameterSyntax,
invocableSymbol,
t,
parameterDirection))));
}
invocableSymbol.ClearParameters();
foreach (var parameter in invocableBinder.LocalSymbols.Values.SelectMany(x => x))
invocableSymbol.AddParameter((ParameterSymbol) parameter);
return boundParameters.ToImmutableArray();
}
