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 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) { ClassOrStructSymbol baseType; List<InterfaceSymbol> baseInterfaces; BindBaseList(declaration.BaseList, parent, out baseType, out baseInterfaces); var structSymbol = new StructSymbol(declaration, parent, baseType, baseInterfaces.ToImmutableArray()); 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) { ClassOrStructSymbol baseType; List<InterfaceSymbol> baseInterfaces; BindBaseList(declaration.BaseList, parent, out baseType, out baseInterfaces); var classBinder = new Binder(_sharedBinderState, this); var classSymbol = new ClassSymbol(declaration, parent, baseType, 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(); }
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))); }