public override void AddNode(GraphMenuItem nodeTreeViewItem)
{
if (nodeTreeViewItem.TypeInfo is INamespaceSymbol)
{
return;
}
if (nodeTreeViewItem.TypeInfo is NodeType nodeType)
{
CreateSpecialNode(nodeType);
return;
}
if (nodeTreeViewItem.TypeInfo is INamedTypeSymbol namedTypeSymbol)
{
if (namedTypeSymbol.SpecialType == SpecialType.System_Void)
{
AddNode(MethodDeclerationNode.Create());
}
else
{
AddNode(VariableNode.Create(namedTypeSymbol.ToDisplayString(), null, namedTypeSymbol.ToString()));
}
}
else if (nodeTreeViewItem.TypeInfo is IMethodSymbol methodSymbol)
{
AddNode(ExternalMethodNode.Create($"{methodSymbol.ContainingType.Name}.{methodSymbol.Name}", methodSymbol.ToString(), methodSymbol.Parameters, methodSymbol.ReturnType));
}
//else if (nodeTreeViewItem.TypeInfo is Void)
//{
//}
//base.AddNode(nodeTreeViewItem);
}
protected override CrawlSyntaxNode VisitMethodDecleration(MethodDeclerationNode methodDecleration)
{
var decl = (MethodDeclerationNode)base.VisitMethodDecleration(methodDecleration);
List <ParameterNode> newParams = new List <ParameterNode>();
foreach (ParameterNode param in decl.Parameters)
{
if (param.Reference) //If it's a reference, don't mess with it.
{
newParams.Add(param);
}
else
{
//If there is any risk of side-effects affecting non-ref parameter, don't optimize to ref.
var visitor = new CheckSideEffectsOfSingleParameterVisitor(param.Identifier.Value);
if (visitor.Visit(methodDecleration.Body))
{
newParams.Add(param);
}
else
{
newParams.Add(CrawlSyntaxNode.Parameter(param.Interval, param.Reference,
false, param.ParameterType, param.Identifier));
}
}
}
return(CrawlSyntaxNode.MethodDecleration(decl.Interval, decl.ProtectionLevel, decl.Scope, decl.MethodSignature,
newParams, decl.Body, decl.Identifier, decl.GenericParameters));
}
public BlockScope CollectIdentifiers(BlockNode block)
{
DeclaringScope declaringScope = DeclaringScope.MethodLike;
if (block.Parent is ClassTypeDeclerationNode)
{
declaringScope = DeclaringScope.ClassLike;
}
ListDictionary <string, TypeInformation> scope = new ListDictionary <string, TypeInformation>();
foreach (var child in block)
{
if (child.Type == NodeType.VariableDecleration)
{
VariableDeclerationNode variableNode = (VariableDeclerationNode)child;
foreach (var decleration in variableNode.Declerations)
{
string name = decleration.Identifier.Name;
scope.Add(name,
new TypeInformation(
variableNode.DeclerationType.ActualType,
variableNode.ProtectionLevel,
decleration.Interval.a,
declaringScope));
}
}
else if (child.Type == NodeType.MethodDecleration)
{
MethodDeclerationNode methodNode = (MethodDeclerationNode)child;
string name = methodNode.Identifier.Value;
scope.Add(name,
new TypeInformation(
methodNode.MethodSignature.ActualType,
methodNode.ProtectionLevel,
methodNode.Interval.a,
declaringScope));
}
}
ConcurrentDictionary <string, TypeInformation[]> newscope = new ConcurrentDictionary <string, TypeInformation[]>(_scopeDictionary);
foreach (KeyValuePair <string, List <TypeInformation> > pair in scope)
{
newscope.TryAdd(pair.Key, pair.Value.ToArray());
}
return(new BlockScope(newscope, _classes));
}
protected override CrawlSyntaxNode VisitMethodDecleration(MethodDeclerationNode methodDecleration)
{
IScope containingScope = methodDecleration.FindFirstScope();
GenericScope scope = new GenericScope(
methodDecleration
.Parameters
.Select(
(parameter, index) =>
new KeyValuePair <string, TypeInformation>(parameter.Identifier.Value,
new TypeInformation(
parameter.ParameterType.ActualType,
ProtectionLevel.NotApplicable,
parameter.Interval.b
)
)
)
);
MethodDeclerationNode node = (MethodDeclerationNode)base.VisitMethodDecleration(methodDecleration);
return(node.WithScope(scope));
}