public static IEnumerable<NamedSymbol> GetTypeSymbols(this SemanticModel semanticModel, SyntaxNode node) { var typesymbols = semanticModel.LookupSymbols(node.SpanStart) .OfType<ILocalSymbol>() .Where(x => x.Locations.Any() && x.Locations.First().GetLineSpan().StartLinePosition < node.GetLocation().GetLineSpan().StartLinePosition) .Select(x => new NamedSymbol( x.Name, x.Type)) .Concat( semanticModel.LookupSymbols(node.SpanStart) .OfType<IParameterSymbol>() .Select(x => new NamedSymbol( x.Name, x.Type)) ).Concat( semanticModel.LookupSymbols(node.SpanStart) .OfType<IPropertySymbol>() .Select(x => new NamedSymbol( x.Name, x.Type)) ).Concat( semanticModel.LookupSymbols(node.SpanStart) .OfType<IFieldSymbol>() .Select(x => new NamedSymbol( x.Name, x.Type)) ); if (!semanticModel.GetEnclosingSymbol(node.SpanStart).IsStatic) { var classDeclaration = node.Ancestors().OfType<ClassDeclarationSyntax>().FirstOrDefault(); if(classDeclaration!=null) { typesymbols = typesymbols.Concat(new NamedSymbol[] { new NamedSymbol( "this",(ITypeSymbol)semanticModel.GetDeclaredSymbol(classDeclaration)) }); } } return typesymbols; }
void Check(SyntaxNode n) { var info = nodeContext.SemanticModel.GetSymbolInfo(n); var symbol = info.Symbol; if ((symbol == null) || (symbol.ContainingType == null) || symbol.ContainingType.Locations.Where(loc => loc.IsInSource && loc.SourceTree.FilePath == type.SyntaxTree.FilePath).All(loc => !type.Span.Contains(loc.SourceSpan))) return; if (!symbol.IsSealed && (symbol.IsVirtual || symbol.IsAbstract || symbol.IsOverride)) { if (symbol.Kind == SymbolKind.Property) { var propertySymbol = symbol as IPropertySymbol; if (propertySymbol != null) { if (n.Ancestors().Any(a => a is AssignmentExpressionSyntax)) { var setterMethodSymbol = propertySymbol.SetMethod; if ((setterMethodSymbol != null) && (setterMethodSymbol.DeclaredAccessibility == Accessibility.Private)) return; } else { var getterMethodSymbol = propertySymbol.GetMethod; if ((getterMethodSymbol != null) && (getterMethodSymbol.DeclaredAccessibility == Accessibility.Private)) return; } } else { return; } } Diagnostics.Add(Diagnostic.Create(descriptor, n.GetLocation())); } }
private static SyntaxNode GetRootNodeOfLine(SyntaxNode node) { int nodeLocationLine = node.GetLocation().GetLineSpan().StartLinePosition.Line; var ancestors = node.Ancestors(); var nodeLocationCharacter = ancestors.Where(ancestor => GetSpanLocation(ancestor).Start.Line == nodeLocationLine) .Min(ancestor => GetSpanLocation(ancestor).Start.Character); return ancestors.Last(ancestor => GetSpanLocation(ancestor).Start == new LinePosition(nodeLocationLine, nodeLocationCharacter)); }
/// <summary> /// Finds first ancestor node such that predicate is met, unless terminateAt is met first. Returns null if terminateAt is true or if no ancestor meets predicate. /// </summary> /// <param name="node">The child node to start from.</param> /// <param name="predicate">The condition to return an ancestor.</param> /// <param name="terminateAt">If this is true for any ancestor, the search will be terminated.</param> /// <returns>The ancestor node that meets the predicate condition, or null if terminateAt is satisfied first or if no ancestor is found.</returns> public static SyntaxNode GetFirstAncestorWhere(this SyntaxNode node, Func <SyntaxNode, bool> predicate, Func <SyntaxNode, bool> terminateAt = null) { terminateAt = terminateAt ?? (_ => false); return(node.Ancestors() .TakeWhile(n => !terminateAt(n)) .Where(predicate) .FirstOrDefault()); }
/// <summary> /// Get the first ancestor which is a member declaration syntax of the provided kind (class, method, namespace, etc) /// </summary> /// <param name="node">The current node</param> /// <param name="includeSelf">If true, the current node will be considered when checking for MemberDeclarationSyntax ancestors</param> /// <param name="takeLast">If true, will grab the last surrounding declaration syntax of the given type. Useful to ignore of nested classes or namespaces</param> /// <returns>The surrounding member declaration syntax</returns> public static MemberDeclarationSyntax GetSurroundingMemberDeclarationSyntax <TMemberDeclarationType>( this SyntaxNode node, bool includeSelf = false, bool takeLast = false) where TMemberDeclarationType : MemberDeclarationSyntax { var ancestors = includeSelf ? node.AncestorsAndSelf() : node.Ancestors(); var target = takeLast ? ancestors.LastOrDefault(ancestor => ancestor.IsSyntaxOfType <TMemberDeclarationType>()) : ancestors.FirstOrDefault(ancestor => ancestor.IsSyntaxOfType <TMemberDeclarationType>()); return(target as TMemberDeclarationType); }
/// <summary> /// Indicates if this node is directly or conditionally returned in the context of its declaration /// </summary> /// <param name="node">The node to check</param> /// <returns>Is the node is an active member of a return statement</returns> public static bool IsReturned(this SyntaxNode node) { if (node.Parent.IsSyntaxOfType <ReturnStatementSyntax>()) { return(true); } var ancestorsUntilReturn = node.Ancestors() .TakeWhile(ancestor => !ancestor.IsSyntaxOfType <ReturnStatementSyntax>() && IsConditionalOrCoalesce(node)); var returnStatement = ancestorsUntilReturn.LastOrDefault()?.Parent?.GetAsSyntaxOfType <ReturnStatementSyntax>(); return(returnStatement != null && returnStatement.Expression.GetAsSyntaxOfType <ConditionalExpressionSyntax>()?.Condition != node); }
/// <summary> /// True if the given syntax node is in the scope of a state. /// </summary> /// <param name="node">SyntaxNode</param> /// <returns>Boolean</returns> protected bool IsInStateScope(SyntaxNode node) { var result = false; var ancestors = node.Ancestors().OfType<ClassDeclarationSyntax>().ToList(); foreach (var ancestor in ancestors) { result = this.Project.PSharpPrograms. SelectMany(p => p.NamespaceDeclarations). SelectMany(n => n.MachineDeclarations). SelectMany(m => m.StateDeclarations). Any(s => s.Identifier.TextUnit.Text.Equals(ancestor.Identifier.ValueText)); if (result) { break; } } return result; }
public string GenerateName(SyntaxNode node) { Debug.Assert(IsNameableNode(node)); var builder = new StringBuilder(); var ancestors = node.Ancestors().ToArray(); for (int i = ancestors.Length - 1; i >= 0; i--) { var ancestor = ancestors[i]; // We skip "unnameable" nodes to ensure that we don't add empty names // for nodes like the compilation unit or field declarations. if (IsNameableNode(ancestor)) { AppendNodeName(builder, ancestor); } } AppendNodeName(builder, node); return builder.ToString(); }
private static void FixMissingType(SyntaxNode node, Scope scope) { var type = node .Ancestors() .OfType<TypeDeclarationSyntax>() .FirstOrDefault(); if (type != null) { var typeScope = scope.GetScope<SyntaxToken, SyntaxNode, SemanticModel>(type); if (typeScope != null) { SyntaxNode realType = typeScope.get<SyntaxNode>("__tdef" + node.ToString()); if (realType != null) { realType = RoslynCompiler.Mark(realType); //make sure not to duplicate nodes var document = scope.GetDocument<SyntaxToken, SyntaxNode, SemanticModel>(); document.change(node, RoslynCompiler.ReplaceNode(realType)); } } } }
/// <summary> /// Tries to return the parent machine identifier, if any. /// </summary> /// <param name="node">SyntaxNode</param> /// <param name="machine">MachineDeclaration</param> /// <returns>Boolean value</returns> protected bool TryGetParentMachine(SyntaxNode node, out MachineDeclaration machine) { var result = false; machine = null; var ancestors = node.Ancestors().OfType<ClassDeclarationSyntax>().ToList(); foreach (var ancestor in ancestors) { machine = this.Project.PSharpPrograms. SelectMany(p => p.NamespaceDeclarations). SelectMany(n => n.MachineDeclarations). FirstOrDefault(s => s.Identifier.TextUnit.Text.Equals(ancestor.Identifier.ValueText)); if (machine != null) { result = true; break; } } return result; }
public override void Visit(SyntaxNode node) { var padding = node.Ancestors().Count(); var prepend = node.ChildNodes().Any() ? "[-]" : "[.]"; var line = new string(' ', padding) + prepend + " " + node.GetType().ToString(); Console.WriteLine(line); base.Visit(node); }
protected override bool CanAddImportForType(Diagnostic diagnostic, ref SyntaxNode node) { switch (diagnostic.Id) { case CS0103: case CS0246: case CS0305: case CS0308: case CS0122: case CS0307: case CS0616: case CS1003: case CS1580: case CS1581: break; case CS1002: //// only lookup errors inside ParenthesizedLambdaExpression e.g., () => { ... } if (node.Ancestors().OfType<ParenthesizedLambdaExpressionSyntax>().Any()) { if (node is SimpleNameSyntax) { break; } else if (node is BlockSyntax || node is MemberAccessExpressionSyntax || node is BinaryExpressionSyntax) { var last = node.DescendantNodes().OfType<SimpleNameSyntax>().LastOrDefault(); if (!TryFindStandaloneType(ref node)) { node = node.DescendantNodes().OfType<SimpleNameSyntax>().FirstOrDefault(); } else { node = last; } } } else { return false; } break; case CS1574: case CS1584: var cref = node as QualifiedCrefSyntax; if (cref != null) { node = cref.Container; } break; default: return false; } return TryFindStandaloneType(ref node); }
private static SyntaxNode GetContainingMember(SyntaxNode oldNode) { var parenthesizedLambda = oldNode .Ancestors() .FirstOrDefault(n => n.IsKind(SyntaxKind.ParenthesizedLambdaExpression)); if (parenthesizedLambda != null) { return parenthesizedLambda; } var simpleLambda = oldNode .Ancestors() .FirstOrDefault(n => n.IsKind(SyntaxKind.SimpleLambdaExpression)); if (simpleLambda != null) { return simpleLambda; } return oldNode .Ancestors() .FirstOrDefault(n => n.IsKind(SyntaxKind.MethodDeclaration)); }
public override void Visit(SyntaxNode node) { var padding = node.Ancestors().Count(); var prepend = node.ChildNodes().Any() ? "[-]" : "[.]"; var nodetype = node.GetType().FullName; if (nodetype.StartsWith(prefix)) nodetype = nodetype.Substring(prefix.Length); var line = new string(' ', padding) + prepend + " " + nodetype; Console.WriteLine(line); //var decl = node as ClassDeclarationSyntax; //if (decl != null && decl.BaseList != null) //{ // Console.Write(new string(' ', padding + 4) + decl.Identifier); // foreach (var n in decl.BaseList.Types.OfType<IdentifierNameSyntax>()) // { // Console.Write(" " + n.Identifier); // } // Console.WriteLine(); //} var attr = node as AttributeSyntax; if (attr != null) { Console.WriteLine(new string(' ', padding + 4) + "> " + attr.Name); foreach (var arg in attr.ArgumentList.Arguments) { var expr = arg.Expression as LiteralExpressionSyntax; //Console.WriteLine(new string(' ', padding + 4) + "> " + arg.NameColon + " " + arg.NameEquals); Console.WriteLine(new string(' ', padding + 4) + "> " + (expr == null ? null : expr.Token.Value)); } } var attr2 = node as IdentifierNameSyntax; if (attr2 != null) { Console.WriteLine(new string(' ', padding + 4) + "T " + attr2.Identifier.GetType()); Console.WriteLine(new string(' ', padding + 4) + "V " + attr2.Identifier); } var x = node as TypeSyntax; if (x != null) { var xtype = x.GetType().FullName; if (xtype.StartsWith(prefix)) xtype = nodetype.Substring(prefix.Length); Console.WriteLine(new string(' ', padding + 4) + "> " + xtype); } base.Visit(node); }
private static IEnumerable<string> GetIdentifiersInScope(SyntaxNode node) { var withinFirstClass = true; foreach (var ancestor in node.Ancestors()) { switch (ancestor.Kind()) { case SyntaxKind.IndexerDeclaration: var indexerDeclarationSyntax = (IndexerDeclarationSyntax)ancestor; foreach (var parameter in indexerDeclarationSyntax.ParameterList.Parameters) { yield return parameter.Identifier.ValueText; } break; case SyntaxKind.ConstructorDeclaration: var constructorDeclarationSyntax = (ConstructorDeclarationSyntax)ancestor; foreach (var parameter in constructorDeclarationSyntax.ParameterList.Parameters) { yield return parameter.Identifier.ValueText; } break; case SyntaxKind.ParenthesizedLambdaExpression: var parenthesizedLambdaExpressionSyntax = (ParenthesizedLambdaExpressionSyntax)ancestor; foreach (var parameter in parenthesizedLambdaExpressionSyntax.ParameterList.Parameters) { yield return parameter.Identifier.ValueText; } break; case SyntaxKind.SimpleLambdaExpression: yield return ((SimpleLambdaExpressionSyntax)ancestor).Parameter.Identifier.ValueText; break; case SyntaxKind.MethodDeclaration: var methodDeclarationSyntax = (MethodDeclarationSyntax)ancestor; foreach (var parameter in methodDeclarationSyntax.ParameterList.Parameters) { yield return parameter.Identifier.ValueText; } yield return methodDeclarationSyntax.Identifier.ValueText; if (methodDeclarationSyntax.TypeParameterList != null) { foreach (var typeParameter in methodDeclarationSyntax.TypeParameterList.Parameters) { yield return typeParameter.Identifier.ValueText; } } break; case SyntaxKind.StructDeclaration: case SyntaxKind.ClassDeclaration: var typeDeclarationSyntax = (TypeDeclarationSyntax)ancestor; yield return typeDeclarationSyntax.Identifier.ValueText; if (typeDeclarationSyntax.TypeParameterList != null) { foreach (var typeParameter in typeDeclarationSyntax.TypeParameterList.Parameters) { yield return typeParameter.Identifier.ValueText; } } if (withinFirstClass) { var children = typeDeclarationSyntax.ChildNodes(); foreach (var property in children.OfType<PropertyDeclarationSyntax>()) { yield return property.Identifier.ValueText; } foreach (var field in children.OfType<FieldDeclarationSyntax>()) { foreach (var variable in field.Declaration.Variables) { yield return variable.Identifier.ValueText; } } withinFirstClass = false; } break; } } }
internal void WriteDetectedThreadingNamespaceUsage(Enums.ThreadingNamespaceDetected type, string documentPath, ISymbol symbol, SyntaxNode node) { if (Enums.ThreadingNamespaceDetected.None != type) { Logger usagelog=null; Logger typelog=null; switch (type) { case Enums.ThreadingNamespaceDetected.ThreadClass: usagelog = Logs.TempLog; typelog = Logs.TempLog2; break; case Enums.ThreadingNamespaceDetected.ThreadpoolClass: usagelog = Logs.TempLog3; typelog = Logs.TempLog4; break; case Enums.ThreadingNamespaceDetected.OtherClass: usagelog = Logs.TempLog5; typelog = Logs.TempLog6; break; } SyntaxNode block=null; var temp = node.Ancestors().OfType<BlockSyntax>(); if (temp.Any()) block = temp.First(); else block = node.Ancestors().ElementAt(3); typelog.Info("{0};{1}", symbol.ContainingType, symbol.ToString()); usagelog.Info("{0} {1}\r\n{2}\r\n--------------------------", symbol, documentPath, block); //// Let's get rid of all specific information! //if (!symbol.ReturnsVoid) // returntype = symbol.ReturnType.OriginalDefinition.ToString(); //typelog.Info(@"{0};{1};{2};{3};{4};{5};{6};{7}", AppName, documentPath, type.ToString(), returntype, symbol.OriginalDefinition.ContainingNamespace, symbol.OriginalDefinition.ContainingType, symbol.OriginalDefinition.Name, ((MethodSymbol)symbol.OriginalDefinition).Parameters); } }
public override SyntaxNode Visit(SyntaxNode node) { Context.LastNode = node; try { if (node is NameEqualsSyntax) return (node); // SyntaxNode visit; //Needs update // if (FixPropertyUnaryExpressions(node, out visit)) // return visit; if (node is IdentifierNameSyntax && // (node.Parent is ExpressionSyntax || node.Parent is MethodDeclarationSyntax || node.Parent is PropertyDeclarationSyntax // || node.Parent is BlockSyntax) && !(node.Parent.Parent is InitializerExpressionSyntax) && !(node.Parent is QualifiedNameSyntax) && !(node.Parent is MemberAccessExpressionSyntax) && !(node.Parent is ThisExpressionSyntax)) { //Lets fully qualify these so that we can have property code working var symbolInfo = _semanticModel.GetSymbolInfo(node); if (symbolInfo.Symbol != null && (symbolInfo.Symbol.Kind == SymbolKind.Field || symbolInfo.Symbol.Kind == SymbolKind.Property)) { if (symbolInfo.Symbol.ContainingType != null && symbolInfo.Symbol.IsStatic) { var newName = symbolInfo.Symbol.ContainingType.GetFullNameCSharp() + "." + symbolInfo.Symbol.Name; return SyntaxFactory.ParseExpression(newName); } else { var firstParent = TypeProcessor.GetDeclaredSymbol(node.Ancestors().OfType<BaseTypeDeclarationSyntax>().First()); //_semanticModel.GetSymbolInfo(node.Ancestors().OfType<BaseTypeDeclarationSyntax>().First()); if (symbolInfo.Symbol.ContainingType != null && !symbolInfo.Symbol.IsStatic && symbolInfo.Symbol.ContainingType == firstParent) return SyntaxFactory.ParseExpression("this." + symbolInfo.Symbol.Name); } return base.Visit(node); } } if (node is MemberAccessExpressionSyntax && // (node.Parent is ExpressionSyntax || node.Parent is MethodDeclarationSyntax || node.Parent is PropertyDeclarationSyntax // || node.Parent is BlockSyntax) && !(node.Parent.Parent is InitializerExpressionSyntax) && !(node.Parent is QualifiedNameSyntax) && !(node.Parent is MemberAccessExpressionSyntax) && !(node.Parent is ThisExpressionSyntax)) { var nodeasMember = node as MemberAccessExpressionSyntax; if (!(nodeasMember.Expression is ThisExpressionSyntax)) { //Lets fully qualify these so that we can have property code working var symbolInfo = _semanticModel.GetSymbolInfo(node); if (symbolInfo.Symbol != null && (symbolInfo.Symbol.Kind == SymbolKind.Field || symbolInfo.Symbol.Kind == SymbolKind.Property)) { if (symbolInfo.Symbol.ContainingType != null && symbolInfo.Symbol.IsStatic) { var newName = symbolInfo.Symbol.ContainingType.GetFullNameCSharp() + "." + symbolInfo.Symbol.Name; return SyntaxFactory.ParseExpression(newName); } else { ISymbol symbol = TypeProcessor.GetSymbolInfo((node as MemberAccessExpressionSyntax).Expression).Symbol; if ( symbol != null && (!(symbol is ILocalSymbol) && !(symbol is IParameterSymbol) && symbol.Name != ".ctor")) { var firstParent = TypeProcessor.GetDeclaredSymbol( node.Ancestors().OfType<BaseTypeDeclarationSyntax>().First()); //_semanticModel.GetSymbolInfo(node.Ancestors().OfType<BaseTypeDeclarationSyntax>().First()); if (symbolInfo.Symbol.ContainingType != null && !symbolInfo.Symbol.IsStatic && symbolInfo.Symbol.ContainingType == firstParent) return SyntaxFactory.ParseExpression("this." + node.ToFullString()); } } } return base.Visit(node); } } return base.Visit(node); } catch (Exception ex) { throw ex; } }