private BoundNode BindGlobalDeclaration(SyntaxNode declaration, Symbol parent)
{
switch (declaration.Kind)
{
case SyntaxKind.VariableDeclarationStatement:
return BindVariableDeclarationStatement((VariableDeclarationStatementSyntax) declaration, parent);
case SyntaxKind.FunctionDeclaration:
return BindFunctionDeclaration((FunctionDeclarationSyntax) declaration, parent);
case SyntaxKind.FunctionDefinition:
return BindFunctionDefinition((FunctionDefinitionSyntax) declaration, parent);
case SyntaxKind.ConstantBufferDeclaration:
return BindConstantBufferDeclaration((ConstantBufferSyntax) declaration);
case SyntaxKind.TypeDeclarationStatement:
return BindTypeDeclaration((TypeDeclarationStatementSyntax) declaration, parent);
case SyntaxKind.Namespace:
return BindNamespace((NamespaceSyntax) declaration);
case SyntaxKind.TechniqueDeclaration:
return BindTechniqueDeclaration((TechniqueSyntax) declaration);
case SyntaxKind.TypedefStatement:
return BindTypedefStatement((TypedefStatementSyntax) declaration);
case SyntaxKind.EmptyStatement:
return BindEmptyStatement((EmptyStatementSyntax) declaration);
default:
throw new ArgumentOutOfRangeException(declaration.Kind.ToString());
}
}
private BoundStatement BindStatement(StatementSyntax syntax, Symbol parent)
{
switch (syntax.Kind)
{
case SyntaxKind.Block:
return BindBlock((BlockSyntax) syntax, parent);
case SyntaxKind.BreakStatement:
return BindBreakStatement((BreakStatementSyntax) syntax);
case SyntaxKind.DiscardStatement:
return BindDiscardStatement((DiscardStatementSyntax) syntax);
case SyntaxKind.DoStatement:
return BindDoStatement((DoStatementSyntax) syntax, parent);
case SyntaxKind.ExpressionStatement:
return BindExpressionStatement((ExpressionStatementSyntax) syntax);
case SyntaxKind.ForStatement:
return BindForStatement((ForStatementSyntax) syntax, parent);
case SyntaxKind.IfStatement:
return BindIfStatement((IfStatementSyntax) syntax, parent);
case SyntaxKind.ReturnStatement:
return BindReturnStatement((ReturnStatementSyntax) syntax);
case SyntaxKind.VariableDeclarationStatement:
return BindVariableDeclarationStatement((VariableDeclarationStatementSyntax) syntax, parent);
case SyntaxKind.SwitchStatement:
return BindSwitchStatement((SwitchStatementSyntax) syntax, parent);
case SyntaxKind.WhileStatement:
return BindWhileStatement((WhileStatementSyntax) syntax, parent);
case SyntaxKind.EmptyStatement:
return BindEmptyStatement((EmptyStatementSyntax) syntax);
default:
throw new NotSupportedException("Not supported: " + syntax.Kind);
}
}
internal Symbol(SymbolKind kind, string name, string documentation, Symbol parent)
{
Kind = kind;
Name = name;
Documentation = documentation;
Parent = parent;
}
protected bool EqualsImpl(Symbol other)
{
return Kind == other.Kind
&& string.Equals(Name, other.Name)
&& (Parent == null) == (other.Parent == null)
&& (Parent == null || Parent.EqualsImpl(other.Parent));
}
private BoundStatement BindDoStatement(DoStatementSyntax syntax, Symbol parent)
{
BindAttributes(syntax.Attributes);
return new BoundDoStatement(
Bind(syntax.Condition, BindExpression),
Bind(syntax.Statement, x => BindStatement(x, parent)));
}
internal ParameterSymbol(string name, string documentation, Symbol parent, TypeSymbol valueType, ParameterDirection direction = ParameterDirection.In)
: base(SymbolKind.Parameter, name, documentation, parent, valueType)
{
if (valueType == null)
throw new ArgumentNullException(nameof(valueType));
Direction = direction;
}
public CompletionItem(string displayText, string insertionText, string description, Glyph? glyph, Symbol symbol, bool isBuilder)
{
DisplayText = displayText;
InsertionText = insertionText;
Description = description;
Glyph = glyph;
Symbol = symbol;
IsBuilder = isBuilder;
}
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);
}
internal InvocableSymbol(SymbolKind kind, string name, string documentation, Symbol parent, TypeSymbol returnType, Func<InvocableSymbol, IEnumerable<ParameterSymbol>> lazyParameters = null)
: base(kind, name, documentation, parent)
{
if (returnType == null)
throw new ArgumentNullException(nameof(returnType));
_parameters = new List<ParameterSymbol>();
if (lazyParameters != null)
foreach (var parameter in lazyParameters(this))
AddParameter(parameter);
ReturnType = returnType;
}
public static IEnumerable<SymbolSpan> FindUsages(this SemanticModel semanticModel, Symbol symbol)
{
if (semanticModel == null)
throw new ArgumentNullException(nameof(semanticModel));
if (symbol == null)
throw new ArgumentNullException(nameof(symbol));
var syntaxTree = semanticModel.SyntaxTree;
return from n in syntaxTree.Root.DescendantNodes()
from s in GetSymbolSpans(semanticModel, n)
where s.Symbol.Equals(symbol)
select s;
}
private BoundType BindType(TypeSyntax syntax, Symbol parent)
{
switch (syntax.Kind)
{
case SyntaxKind.PredefinedScalarType:
return BindScalarType((ScalarTypeSyntax) syntax);
case SyntaxKind.PredefinedVectorType:
return BindVectorType((VectorTypeSyntax) syntax);
case SyntaxKind.PredefinedGenericVectorType:
return BindGenericVectorType((GenericVectorTypeSyntax) syntax);
case SyntaxKind.PredefinedMatrixType:
return BindMatrixType((MatrixTypeSyntax) syntax);
case SyntaxKind.PredefinedGenericMatrixType:
return BindGenericMatrixType((GenericMatrixTypeSyntax) syntax);
case SyntaxKind.PredefinedObjectType:
return new BoundObjectType(BindObjectType((PredefinedObjectTypeSyntax) syntax));
case SyntaxKind.StructType:
{
// Inline struct.
return BindStructDeclaration((StructTypeSyntax) syntax, parent);
}
case SyntaxKind.IdentifierName:
{
var identifierName = (IdentifierNameSyntax) syntax;
var symbols = LookupTypeSymbol(identifierName.Name).ToImmutableArray();
if (symbols.Length == 0)
{
Diagnostics.ReportUndeclaredType(syntax);
return new BoundUnknownType();
}
if (symbols.Length > 1)
Diagnostics.ReportAmbiguousType(identifierName.Name, symbols);
return new BoundName(symbols.First());
}
case SyntaxKind.QualifiedName:
{
var qualifiedName = (QualifiedNameSyntax) syntax;
return BindQualifiedType(qualifiedName);
}
default:
throw new InvalidOperationException(syntax.Kind.ToString());
}
}
internal NamespaceSymbol(NamespaceSyntax syntax, Symbol parent)
: base(SymbolKind.Namespace, syntax.Name.Text, string.Empty, parent)
{
Syntax = syntax;
}
private BoundType BindTypeDefinition(TypeDefinitionSyntax syntax, Symbol parent)
{
switch (syntax.Kind)
{
case SyntaxKind.ClassType:
return BindClassDeclaration((ClassTypeSyntax) syntax, parent);
case SyntaxKind.StructType:
return BindStructDeclaration((StructTypeSyntax) syntax, parent);
case SyntaxKind.InterfaceType:
return BindInterfaceDeclaration((InterfaceTypeSyntax) syntax, parent);
default:
throw new ArgumentOutOfRangeException();
}
}
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 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 BoundFunctionDeclaration BindFunctionDeclaration(FunctionDeclarationSyntax declaration, Symbol parent)
{
BindAttributes(declaration.Attributes);
var boundReturnType = Bind(declaration.ReturnType, x => BindType(x, parent));
var functionSymbol = LocalSymbols.OfType<SourceFunctionSymbol>()
.FirstOrDefault(x => SyntaxFacts.HaveMatchingSignatures(
x.DefinitionSyntax as FunctionSyntax ?? x.DeclarationSyntaxes[0],
declaration));
if (functionSymbol != null)
{
functionSymbol.DeclarationSyntaxes.Add(declaration);
}
else
{
functionSymbol = new SourceFunctionSymbol(declaration, parent, boundReturnType.TypeSymbol);
AddSymbol(functionSymbol, declaration.Name.GetTextSpanSafe(), true);
}
if (declaration.Semantic != null)
Bind(declaration.Semantic, BindVariableQualifier);
var functionBinder = new Binder(_sharedBinderState, this);
var boundParameters = BindParameters(declaration.ParameterList, functionBinder, functionSymbol);
return new BoundFunctionDeclaration(functionSymbol, boundReturnType, boundParameters.ToImmutableArray());
}
private BoundMultipleVariableDeclarations BindVariableDeclaration(VariableDeclarationSyntax syntax, Symbol parent, Func<VariableDeclaratorSyntax, TypeSymbol, VariableSymbol> createSymbol)
{
var boundType = Bind(syntax.Type, x => BindType(x, parent));
var boundDeclarations = new List<BoundVariableDeclaration>();
foreach (var declarator in syntax.Variables)
{
boundDeclarations.Add(Bind(declarator, x => BindVariableDeclarator(x, boundType.TypeSymbol, createSymbol)));
}
return new BoundMultipleVariableDeclarations(boundDeclarations.ToImmutableArray());
}
private BoundMultipleVariableDeclarations BindVariableDeclaration(VariableDeclarationSyntax syntax, Symbol parent)
{
return BindVariableDeclaration(syntax, parent, (d, t) => new VariableSymbol(d, parent, t));
}
public static QuickInfoModel ForSymbol(SemanticModel semanticModel, TextSpan span, Symbol symbol)
{
var glyph = symbol.GetGlyph();
var symbolMarkup = SymbolMarkup.ForSymbol(symbol);
return new QuickInfoModel(semanticModel, span, glyph, symbolMarkup, symbol.Documentation);
}
private ImmutableArray<BoundNode> BindTopLevelDeclarations(List<SyntaxNode> declarations, Symbol parent)
{
return declarations.Select(x => Bind(x, y => BindGlobalDeclaration(y, parent))).ToImmutableArray();
}
internal FunctionSymbol(string name, string documentation, Symbol parent, TypeSymbol returnType, Func<InvocableSymbol, IEnumerable<ParameterSymbol>> lazyParameters = null, bool isNumericConstructor = false)
: base(SymbolKind.Function, name, documentation, parent, returnType, lazyParameters)
{
IsNumericConstructor = isNumericConstructor;
}
private BoundNode BindFunctionDefinition(FunctionDefinitionSyntax declaration, Symbol parent)
{
BindAttributes(declaration.Attributes);
var boundReturnType = Bind(declaration.ReturnType, x => BindType(x, parent));
var isQualifiedName = false;
ContainerSymbol containerSymbol;
Symbol functionOwner;
switch (declaration.Name.Kind)
{
case SyntaxKind.IdentifierDeclarationName:
containerSymbol = null;
functionOwner = parent;
break;
case SyntaxKind.QualifiedDeclarationName:
containerSymbol = LookupContainer(((QualifiedDeclarationNameSyntax) declaration.Name).Left);
if (containerSymbol == null)
return new BoundErrorNode();
isQualifiedName = true;
functionOwner = containerSymbol;
break;
default:
throw new InvalidOperationException();
}
var containerBinder = containerSymbol?.Binder ?? this;
var symbolTable = containerBinder.LocalSymbols;
var functionSymbol = symbolTable
.SelectMany(x => x.Value)
.OfType<SourceFunctionSymbol>()
.FirstOrDefault(x => SyntaxFacts.HaveMatchingSignatures(
x.DefinitionSyntax as FunctionSyntax ?? x.DeclarationSyntaxes[0],
declaration));
if (functionSymbol != null)
{
if (functionSymbol.DefinitionSyntax != null)
Diagnostics.ReportSymbolRedefined(declaration.Name.GetTextSpanSafe(), functionSymbol);
else
functionSymbol.DefinitionSyntax = declaration;
}
else
{
if (isQualifiedName)
Diagnostics.ReportUndeclaredFunctionInNamespaceOrClass((QualifiedDeclarationNameSyntax) declaration.Name);
functionSymbol = new SourceFunctionSymbol(declaration, parent, boundReturnType.TypeSymbol);
containerBinder.AddSymbol(functionSymbol, declaration.Name.GetTextSpanSafe(), true);
}
if (declaration.Semantic != null)
Bind(declaration.Semantic, BindVariableQualifier);
var functionBinder = (functionOwner != null && functionOwner.Kind == SymbolKind.Class)
? new ClassMethodBinder(_sharedBinderState, this, (ClassSymbol) functionOwner)
: new Binder(_sharedBinderState, this);
if (isQualifiedName)
functionBinder = new ContainedFunctionBinder(_sharedBinderState, functionBinder, containerSymbol.Binder);
var boundParameters = BindParameters(declaration.ParameterList, functionBinder, functionSymbol);
var boundBody = functionBinder.Bind(declaration.Body, x => functionBinder.BindBlock(x, functionSymbol));
return new BoundFunctionDefinition(functionSymbol, boundReturnType, boundParameters.ToImmutableArray(), boundBody);
}
internal ClassSymbol(ClassTypeSyntax syntax, Symbol parent, ClassOrStructSymbol baseType, ImmutableArray<InterfaceSymbol> baseInterfaces, Binder binder)
: base(SymbolKind.Class, syntax.Name.Text, parent, baseType, baseInterfaces)
{
Syntax = syntax;
Binder = binder;
}
private void BindBaseList(BaseListSyntax baseList, Symbol parent, out ClassOrStructSymbol baseType, out List<InterfaceSymbol> baseInterfaces)
{
baseType = null;
baseInterfaces = new List<InterfaceSymbol>();
if (baseList != null)
{
var baseTypeTemp = Bind(baseList.BaseType, x => BindType(x, parent));
switch (baseTypeTemp.TypeSymbol.Kind)
{
case SymbolKind.Class:
case SymbolKind.Struct:
baseType = (ClassOrStructSymbol) baseTypeTemp.TypeSymbol;
break;
case SymbolKind.Interface:
baseInterfaces.Add((InterfaceSymbol) baseTypeTemp.TypeSymbol);
break;
}
}
}
internal VariableSymbol(SymbolKind kind, string name, string documentation, Symbol parent, TypeSymbol valueType)
: base(kind, name, documentation, parent)
{
ValueType = valueType;
}
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());
}
internal VariableSymbol(VariableDeclaratorSyntax syntax, Symbol parent, TypeSymbol valueType)
: base(SymbolKind.Variable, syntax.Identifier.Text, string.Empty, parent)
{
ValueType = valueType;
}
private BoundTypeDeclaration BindTypeDeclaration(TypeDeclarationStatementSyntax declaration, Symbol parent)
{
return new BoundTypeDeclaration(Bind(declaration.Type, x => BindTypeDefinition(x, parent)));
}
internal InterfaceSymbol(InterfaceTypeSyntax syntax, Symbol parent)
: base(SymbolKind.Interface, syntax.Name.Text, string.Empty, parent)
{
}
public BoundName(Symbol symbol)
: base(BoundNodeKind.Name, symbol as TypeSymbol ?? TypeFacts.Missing)
{
Symbol = symbol;
}
internal SourceFunctionSymbol(FunctionDeclarationSyntax syntax, Symbol parent, TypeSymbol returnType, Func<InvocableSymbol, IEnumerable<ParameterSymbol>> lazyParameters = null)
: base(syntax.Name.GetName(), string.Empty, parent, returnType, lazyParameters)
{
DeclarationSyntaxes = new List<FunctionDeclarationSyntax> { syntax };
}