private void BindClassDeclaration(ClassTypeSyntax declaration)
{
Func <TypeSymbol, IEnumerable <MemberSymbol> > lazyMemberSymbols = cd =>
{
var memberSymbols = new List <MemberSymbol>();
foreach (var memberSyntax in declaration.Members)
{
switch (memberSyntax.Kind)
{
case SyntaxKind.VariableDeclarationStatement:
memberSymbols.AddRange(BindFields((VariableDeclarationStatementSyntax)memberSyntax, cd));
break;
case SyntaxKind.FunctionDeclaration:
memberSymbols.Add(BindMethodDeclaration((FunctionDeclarationSyntax)memberSyntax, cd));
break;
case SyntaxKind.FunctionDefinition:
memberSymbols.Add(BindMethodDefinition((FunctionDefinitionSyntax)memberSyntax, cd));
break;
}
}
return(memberSymbols);
};
var symbol = new ClassSymbol(declaration, null, lazyMemberSymbols);
_bindingResult.AddSymbol(declaration, symbol);
_symbolSet.AddGlobal(symbol);
}
public override void VisitClassType(ClassTypeSyntax node)
{
var symbol = _semanticModel.GetDeclaredSymbol(node);
if (symbol != null)
CreateTag(node.Name, _classificationService.ClassIdentifier);
base.VisitClassType(node);
}
internal ClassSymbol(ClassTypeSyntax syntax, Symbol parent, ClassSymbol baseClass, ImmutableArray <InterfaceSymbol> baseInterfaces, Binder binder)
: base(SymbolKind.Class, syntax.Name.Text, string.Empty, parent)
{
Syntax = syntax;
BaseClass = baseClass;
BaseInterfaces = baseInterfaces;
Binder = binder;
}
public override void VisitClassType(ClassTypeSyntax node)
{
ProcessItem(node.Name, node.Name.Text, node.GetTextSpanSafe(), NavigateToItemKind.Class, node.Parent, Glyph.Class);
foreach (var member in node.Members)
{
Visit(member);
}
}
public override void VisitClassType(ClassTypeSyntax node)
{
var symbol = _semanticModel.GetDeclaredSymbol(node);
if (symbol != null)
{
CreateTag(node.Name, _classificationService.ClassIdentifier);
}
base.VisitClassType(node);
}
public virtual void VisitClassType(ClassTypeSyntax node)
{
this.BeginSymbolUse(node, types: ImmutableArray.Create(typeof(MetaClass), typeof(MetaEnum), typeof(MetaConstant)));
try
{
this.Visit(node.Qualifier);
}
finally
{
this.EndSymbolUse();
}
}
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 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.SourceRange);
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.BindField(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()));
}
public override IEnumerable <EditorNavigationTarget> VisitClassType(ClassTypeSyntax node)
{
yield return(CreateTypeTarget(node.Name, node.GetTextSpanSafe(), Glyph.Class, node.Members));
}
public ClassSymbol GetDeclaredSymbol(ClassTypeSyntax syntax)
{
var result = _bindingResult.GetBoundNode(syntax) as BoundClassType;
return result?.ClassSymbol;
}
public override void VisitClassType(ClassTypeSyntax node)
{
CreateTag(node.Name, _classificationService.ClassIdentifier);
base.VisitClassType(node);
}
public virtual void VisitClassType(ClassTypeSyntax node)
{
DefaultVisit(node);
}
private void BindClassDeclaration(ClassTypeSyntax declaration)
{
Func<TypeSymbol, IEnumerable<MemberSymbol>> lazyMemberSymbols = cd =>
{
var memberSymbols = new List<MemberSymbol>();
foreach (var memberSyntax in declaration.Members)
{
switch (memberSyntax.Kind)
{
case SyntaxKind.VariableDeclarationStatement:
memberSymbols.AddRange(BindFields((VariableDeclarationStatementSyntax)memberSyntax, cd));
break;
case SyntaxKind.FunctionDeclaration:
memberSymbols.Add(BindMethodDeclaration((FunctionDeclarationSyntax)memberSyntax, cd));
break;
case SyntaxKind.FunctionDefinition:
memberSymbols.Add(BindMethodDefinition((FunctionDefinitionSyntax)memberSyntax, cd));
break;
}
}
return memberSymbols;
};
var symbol = new ClassSymbol(declaration, null, lazyMemberSymbols);
_bindingResult.AddSymbol(declaration, symbol);
_symbolSet.AddGlobal(symbol);
}
public override void VisitClassType(ClassTypeSyntax node)
{
CreateTag(node.Name, _classificationService.ClassIdentifier);
base.VisitClassType(node);
}
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());
}
public override void VisitClassType(ClassTypeSyntax node)
{
ProcessItem(node.Name, node.Name.Text, node.GetTextSpanSafe(), NavigateToItemKind.Class, node.Parent, Glyph.Class);
foreach (var member in node.Members)
Visit(member);
}
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());
}
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;
}
public ClassSymbol GetDeclaredSymbol(ClassTypeSyntax syntax)
{
var result = _bindingResult.GetBoundNode(syntax) as BoundClassType;
return(result?.ClassSymbol);
}
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;
}
public virtual void VisitClassType(ClassTypeSyntax node)
{
DefaultVisit(node);
}
public ClassSymbol(ClassTypeSyntax syntax, Symbol parent, Func<TypeSymbol, IEnumerable<MemberSymbol>> lazyMembers)
: base(SymbolKind.Class, syntax.Name.Text, string.Empty, parent, lazyMembers)
{
}
public ClassSymbol(ClassTypeSyntax syntax, Symbol parent, Func <TypeSymbol, IEnumerable <MemberSymbol> > lazyMembers)
: base(SymbolKind.Class, syntax.Name.Text, string.Empty, parent, lazyMembers)
{
}
