private static void TestVisibility(string source, string enumName, SyntaxKind?expectedVisibility) { // Assembling some code IAssemblyLoader assemblyLoader = new Utils.AsmlDasmlAssemblyLoader(source); // Loading the assembly IAssemblyProxy assembly = assemblyLoader.Load(); // Locating the enum ITypeInfoProxy enumDefinition = assembly.LocateType(enumName); Assert.IsNotNull(enumDefinition); // Generating the AST var factory = new EnumDeclarationSyntaxFactory(enumDefinition); var syntaxNode = factory.Create(); Assert.IsNotNull(syntaxNode, "A node was expected to be built"); Assert.IsInstanceOfType(syntaxNode, typeof(EnumDeclarationSyntax), "Expected an enum declaration node to be built"); var enumDeclarationSyntaxNode = syntaxNode as EnumDeclarationSyntax; var modifiers = enumDeclarationSyntaxNode.Modifiers; if (expectedVisibility.HasValue) { Assert.IsTrue(Utils.CheckModifier(modifiers, expectedVisibility.Value), "Enum does not have correct visibility"); return; } Assert.AreEqual(0, modifiers.Count(), "Expected no modifier"); }
public static PropertyDeclarationSyntax AutoPropertyDeclaration( IEnumerable <SyntaxKind> modifiers, TypeSyntax type, string propertyName, SyntaxKind?setModifier = null, SyntaxKind?getModifier = null, bool isAbstract = false) { var accesors = new List <AccessorDeclarationSyntax>(); if (!(isAbstract && getModifier == SyntaxKind.PrivateKeyword)) { accesors.Add( Syntax.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithModifiers(TokenList(getModifier)) .WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken))); } if (!(isAbstract && setModifier == SyntaxKind.PrivateKeyword)) { accesors.Add( Syntax.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithModifiers(TokenList(setModifier)) .WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken))); } return(Syntax.PropertyDeclaration(type, propertyName) .WithModifiers(TokenList(modifiers)) .WithAccessorList(Syntax.AccessorList(accesors.ToSyntaxList()))); }
public static PropertyDeclarationSyntax AutoPropertyDeclaration( IEnumerable <SyntaxKind> modifiers, string typeName, string propertyName, SyntaxKind?setModifier = null, SyntaxKind?getModifier = null, bool isAbstract = false) { return(AutoPropertyDeclaration( modifiers, Syntax.ParseTypeName(typeName), propertyName, setModifier, getModifier, isAbstract)); }
public sealed override SyntaxNode VisitAnonymousMethodExpression(AnonymousMethodExpressionSyntax node) { if (RewritingSyntaxKind.HasValue) { return(node); } RewritingSyntaxKind = node.Kind(); return(OnVisitAnonymousMethodExpression(node)); }
public sealed override SyntaxNode VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node) { if (RewritingSyntaxKind.HasValue) { return(node); } RewritingSyntaxKind = node.Kind(); return(OnVisitSimpleLambdaExpression(node)); }
public sealed override SyntaxNode VisitLocalFunctionStatement(LocalFunctionStatementSyntax node) { if (RewritingSyntaxKind.HasValue) { return(node); } RewritingSyntaxKind = node.Kind(); return(OnVisitLocalFunctionStatement(node)); }
public static EnumDeclarationSyntax EnumDeclaration( string enumName, IEnumerable <EnumMemberDeclarationSyntax> members, SyntaxKind?baseType = null) { return(Syntax.EnumDeclaration(enumName) .WithModifiers(TokenList(SyntaxKind.PublicKeyword)) .WithBaseList( baseType == null ? null : Syntax.BaseList( new TypeSyntax[] { Syntax.PredefinedType(Syntax.Token(baseType.Value)) } .ToSeparatedList())) .WithMembers(members.ToSeparatedList())); }
private SyntaxKind GetTypeDefaultVisibility(TypeBlockSyntax originalTypeBlockSyntax) { // In the case of partial types we need to use the existing visibility if it exists if (originalTypeBlockSyntax.BlockStatement.Modifiers.Any(x => x.Kind() == SyntaxKind.PartialKeyword)) { SyntaxKind?kind = GetExistingPartialVisibility(originalTypeBlockSyntax); if (kind.HasValue) { return(kind.Value); } } return(GetDelegateTypeDefaultVisibility(originalTypeBlockSyntax)); }
/// <summary> /// Returns the <see cref="SyntaxNode.Parent" /> if its type is /// <typeparam name="TParent"></typeparam> /// . /// </summary> /// <typeparam name="TParent"></typeparam> /// <param name="node">Node to get parent of.</param> /// <param name="kind">Optionally require parent to also be of this kind.</param> /// <returns>Parent or null if not found or not matching type or kind.</returns> public static TParent Parent <TParent>(this SyntaxNode node, SyntaxKind?kind = null) where TParent : SyntaxNode { TParent parent = node.Parent as TParent; if (parent == null) { return(default(TParent)); } if (kind == null) { return(parent); } return(parent.Kind() != kind ? default(TParent) : parent); }
internal static bool IdentifierIsLocalVariable(IdentifierNameSyntax identifier) { SyntaxNode parentMethod = IdentifierUtilities.TryGetParentMethod(identifier.Parent); SyntaxKind?kind = parentMethod?.Kind; if (kind.HasValue) { switch (kind.GetValueOrDefault()) { case SyntaxKind.TriggerDeclaration: return(IdentifierUtilities.VerifyIdentifierIsInMethodTriggerVarParamList <TriggerDeclarationSyntax>((TriggerDeclarationSyntax)parentMethod, identifier)); case SyntaxKind.MethodDeclaration: return(IdentifierUtilities.VerifyIdentifierIsInMethodTriggerVarParamList <MethodDeclarationSyntax>((MethodDeclarationSyntax)parentMethod, identifier)); } } return(false); }
private PostSkipAction SkipBadTokens( Func <HlslParser, bool> isNotExpectedFunction, Func <HlslParser, bool> abortFunction, SyntaxKind?expected = null) { var action = PostSkipAction.Continue; var tokens = new List <SyntaxToken>(); var first = true; while (isNotExpectedFunction(this)) { if (abortFunction(this)) { action = PostSkipAction.Abort; break; } tokens.Add(first && expected != null ? NextTokenWithPrejudice(expected.Value) : NextToken()); first = false; } if (!_scanStack.Any() && tokens.Any()) { var current = _tokens[_tokenIndex]; var skippedTokensTrivia = CreateSkippedTokensTrivia(tokens); var leadingTrivia = new List <SyntaxNode>(current.LeadingTrivia.Length + 1); leadingTrivia.Add(skippedTokensTrivia); leadingTrivia.AddRange(current.LeadingTrivia); _tokens[_tokenIndex] = current .WithLeadingTrivia(leadingTrivia) .WithDiagnostic(Diagnostic.Create( HlslMessageProvider.Instance, tokens.First().SourceRange, (int)DiagnosticId.TokenUnexpected, tokens.First().Text)); } return(action); }
private static IImmutableDictionary <SyntaxKind, TimeSpan> GetHotDurations(SyntaxElement rootElement) { var elements = rootElement.GetDescendants <SyntaxElement>(); var builder = ImmutableDictionary <SyntaxKind, TimeSpan> .Empty.ToBuilder(); SyntaxKind?kind = null; foreach (var e in elements) { if (kind == null) { if (e.Kind == SyntaxKind.HotKeyword || e.Kind == SyntaxKind.HotDataKeyword || e.Kind == SyntaxKind.HotIndexKeyword) { if (!e.IsMissing) { kind = e.Kind; } } } else { if (e.Kind == SyntaxKind.TimespanLiteralToken) { var token = (SyntaxToken)e; var t = (TimeSpan)token.Value; builder.Add(kind.Value, t); kind = null; } } } return(builder.ToImmutable()); }
public static PropertyDeclarationSyntax PropertyDeclaration( IEnumerable <SyntaxKind> modifiers, TypeSyntax type, string propertyName, IEnumerable <StatementSyntax> getStatements, SyntaxKind?getModifier = null, IEnumerable <StatementSyntax> setStatements = null, SyntaxKind?setModifier = null) { var accessors = new List <AccessorDeclarationSyntax>(); accessors.Add( Syntax.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithModifiers(TokenList(getModifier)) .WithBody(Syntax.Block(getStatements.ToSyntaxList()))); if (setStatements != null) { accessors.Add( Syntax.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithModifiers(TokenList(setModifier)) .WithBody(Syntax.Block(setStatements.ToSyntaxList()))); } return(Syntax.PropertyDeclaration(type, propertyName) .WithModifiers(TokenList(modifiers)) .WithAccessorList(Syntax.AccessorList(accessors.ToSyntaxList()))); }
public override bool IsSimpleMemberAccessExpressionNode(SyntaxNode node) { SyntaxKind?kind = node?.Kind(); return(kind == SyntaxKind.SimpleMemberAccessExpression); }
public override bool IsObjectCreationExpressionNode(SyntaxNode node) { SyntaxKind?kind = node?.Kind(); return(kind == SyntaxKind.ObjectCreationExpression); }
internal static PropertyDeclarationSyntax CreateAutoProperty(TypeSyntax type, string identifier, SyntaxList <AccessorDeclarationSyntax> accessors, SyntaxKind?accessibility) { var newProperty = SyntaxFactory.PropertyDeclaration(type, identifier) .WithAccessorList(SyntaxFactory.AccessorList(accessors)); if (accessibility.HasValue) { newProperty = newProperty.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(accessibility.Value))); } return(newProperty.WithAdditionalAnnotations(Formatter.Annotation)); }
private static int CountArguments(IEnumerable <SyntaxNode> childNodes, SyntaxKind?kind = null) => childNodes.OfType <ArgumentListSyntax>().Where(s => s.Arguments.Any(a => a.Expression.Kind() == kind)).Select(s => s.Arguments.Count).FirstOrDefault();
protected ExpressionSelectorBase(SyntaxKind?kind = null) { this.kind = kind; }
private void AddSemanticRange(SyntaxNode node, SyntaxKind?kind = null) { if (node is null) { throw new ArgumentNullException(nameof(node)); } if (kind is null) { kind = node.Kind; } if (node.Width == 0) { // Under no circumstances can we have 0-width spans. // This can happen in situations like "@* comment ", where EndCommentStar and EndCommentTransition are empty. return; } int semanticKind; switch (kind) { case SyntaxKind.MarkupTagHelperDirectiveAttribute: case SyntaxKind.MarkupMinimizedTagHelperDirectiveAttribute: semanticKind = RazorSemanticTokensLegend.RazorDirectiveAttribute; break; case SyntaxKind.MarkupTagHelperStartTag: case SyntaxKind.MarkupTagHelperEndTag: semanticKind = RazorSemanticTokensLegend.RazorTagHelperElement; break; case SyntaxKind.MarkupTagHelperAttribute: case SyntaxKind.MarkupMinimizedTagHelperAttribute: semanticKind = RazorSemanticTokensLegend.RazorTagHelperAttribute; break; case SyntaxKind.Transition: semanticKind = RazorSemanticTokensLegend.RazorTransition; break; case SyntaxKind.Colon: semanticKind = RazorSemanticTokensLegend.RazorDirectiveColon; break; case SyntaxKind.RazorDirective: semanticKind = RazorSemanticTokensLegend.RazorDirective; break; case SyntaxKind.RazorCommentTransition: semanticKind = RazorSemanticTokensLegend.RazorCommentTransition; break; case SyntaxKind.RazorCommentStar: semanticKind = RazorSemanticTokensLegend.RazorCommentStar; break; case SyntaxKind.RazorCommentLiteral: semanticKind = RazorSemanticTokensLegend.RazorComment; break; case SyntaxKind.RazorComment: semanticKind = RazorSemanticTokensLegend.RazorComment; break; case SyntaxKind.OpenAngle: case SyntaxKind.CloseAngle: case SyntaxKind.ForwardSlash: semanticKind = RazorSemanticTokensLegend.MarkupTagDelimiter; break; case SyntaxKind.Equals: semanticKind = RazorSemanticTokensLegend.MarkupOperator; break; case SyntaxKind.MarkupElement: semanticKind = RazorSemanticTokensLegend.MarkupElement; break; case SyntaxKind.MarkupAttributeBlock: semanticKind = RazorSemanticTokensLegend.MarkupAttribute; break; case SyntaxKind.MarkupCommentBlock: semanticKind = RazorSemanticTokensLegend.MarkupComment; break; default: throw new NotImplementedException(); } AddSemanticRange(node, semanticKind); }
private SyntaxToken LexDirectiveToken() { _kind = SyntaxKind.BadToken; _contextualKind = SyntaxKind.BadToken; _diagnostics.Clear(); _start = _charReader.Position; var trailingTrivia = new List<SyntaxNode>(); var isEndOfLine = false; switch (_charReader.Current) { case '#': NextChar(); if (_charReader.Current == '#') { NextChar(); _kind = SyntaxKind.HashHashToken; } else { _kind = SyntaxKind.HashToken; _currentDirectiveKind = null; } break; case '\r': case '\n': _kind = SyntaxKind.EndOfDirectiveToken; _currentDirectiveKind = null; isEndOfLine = true; break; case '\0': _kind = SyntaxKind.EndOfDirectiveToken; _currentDirectiveKind = null; break; case '<': if (_currentDirectiveKind != SyntaxKind.IncludeKeyword) goto default; ReadBracketedString(); break; default: ReadToken(); if (_contextualKind.IsPreprocessorDirective()) _currentDirectiveKind = _contextualKind; break; } var end = _charReader.Position; var kind = _kind; var span = TextSpan.FromBounds(Text, _start, end); var text = Text.GetText(span); var diagnostics = _diagnostics.ToImmutableArray(); LexDirectiveTrailingTrivia(trailingTrivia, kind, isEndOfLine); var token = new SyntaxToken(kind, _contextualKind, false, MakeAbsolute(span), span, text, _value, ImmutableArray<SyntaxNode>.Empty, trailingTrivia.ToImmutableArray(), diagnostics, null, false); return token; }
public sealed override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { RewritingSyntaxKind = node.Kind(); return(OnVisitMethodDeclaration(node)); }
public static IReadOnlyCollection <AttributeListSyntax> Generate(IReadOnlyList <AttributeWrapper> attributes, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, SyntaxKind?target = null) { return(attributes .OrderByAndExclude(excludeMembersAttributes, excludeAttributes) .Select(AttributeSymbolGenerator.Generate) .Where(x => x != null) .Select(x => AttributeList(x !, target)) .OrderBy(x => x.ToFullString()) .ToList()); }
public void AssignmentMutator_ShouldMutate(SyntaxKind input, SyntaxKind expectedOutput, SyntaxKind?additionalOutput = null) { var target = new AssignmentExpressionMutator(); var originalNode = SyntaxFactory.AssignmentExpression( input, SyntaxFactory.IdentifierName("a"), SyntaxFactory.IdentifierName("b") ); var result = target.ApplyMutations(originalNode).ToList(); if (additionalOutput.HasValue && additionalOutput.Value is var additionalExpectedOutput) { result.Count.ShouldBe(2); result.First().ReplacementNode.IsKind(expectedOutput).ShouldBeTrue(); result.Last().ReplacementNode.IsKind(additionalExpectedOutput).ShouldBeTrue(); } else { var mutation = result.ShouldHaveSingleItem(); mutation.ReplacementNode.IsKind(expectedOutput).ShouldBeTrue(); } foreach (var mutation in result) { mutation.Type.ShouldBe(Mutator.Assignment); mutation.DisplayName.ShouldBe($"{input} to {mutation.ReplacementNode.Kind()} mutation"); } }
/// <summary> /// Set operator overloading. /// </summary> /// <param name="operator">Operator to overload</param> /// <returns>The current method builder.</returns> public MethodBuilder WithOperatorOverloading(SyntaxKind @operator) { _overrideOperator = @operator; return(this); }
/// <summary> /// Set operator overloading. /// </summary> /// <param name="operator">Operator to overload</param> /// <returns>The current method builder.</returns> public MethodBuilder WithOperatorOverloading(Operators @operator) { _overrideOperator = OperatorFactory.GetSyntaxKind(@operator); return(this); }
public static void getAssertParams(Dictionary <string, IEnumerable <MethodDeclarationSyntax> > mapDocToPUTNames, List <string> assertStatements) { foreach (var keyValPair in mapDocToPUTNames) { foreach (MethodDeclarationSyntax put in keyValPair.Value) { //Console.WriteLine(put); /* Charles, to number of lines for PUT/UnitTest, just body.Statements.Count*/ Console.WriteLine(put.Identifier); BlockSyntax body = put.Body; //SyntaxList<StatementSyntax> statements = body.Statements; List <ExpressionStatementSyntax> expStmts = body.DescendantNodes().OfType <ExpressionStatementSyntax>().ToList(); foreach (ExpressionStatementSyntax stmt in expStmts) { Console.WriteLine("===="); SyntaxKind?k = stmt?.Expression?.Kind(); if (k != null && k.Equals(SyntaxKind.InvocationExpression)) { //Todo: perhaps double check that statement does start with string "Assert" Console.WriteLine(stmt); SeparatedSyntaxList <ArgumentSyntax> args = ((InvocationExpressionSyntax)stmt.Expression).ArgumentList.Arguments; foreach (ArgumentSyntax arg in args) { //Must Todo: Consider writing a visitor that returns all objects // arguments can be ParenthesizedLambdaExpressionSyntax,IdentiferNameSyntax, elementAccessExpression(for array access), invocationExpressions,MemberAccessExpression,BinaryExpression ,ObjectCreationExpressionSyntax Console.WriteLine(arg); //Console.WriteLine(arg.Expression.Kind()); } } //var param = statement. //var exp = (LocalDeclarationStatementSyntax)statement; //Todo: Filter so that we only get asserts -- if condition may suffice bool isAssert = false; //Console.WriteLine(statement.ToString()); /*foreach(string assertStatement in assertStatements) * { * if (assertStatement.Equals("AssertTextRange")) * { * Console.WriteLine("In AssertTextRange"); * if (statement.ToString().StartsWith("AssertTextRange")) * { * Console.WriteLine(statement); * } * } * if (!assertStatement.Equals("Assert") && assertStatement.StartsWith("Assert")) * { * //Console.WriteLine("In first if"); * if ((statement.ToString().StartsWith(assertStatement))) { * Console.WriteLine("ASSERT1!!!"); * Console.WriteLine(statement); * isAssert = true; * break; * } * * * } else * { * if (statement.ToString().StartsWith("Assert." + assertStatement)) * { * isAssert = true; * Console.WriteLine("ASSERT2!!!"); * Console.WriteLine(statement); * * break; * } * * * * * } * } * if (isAssert) * { * //Console.WriteLine(statement.ToFullString()); * } */ //if (statement.ToString().StartsWith("Assert")) //{ // Console.WriteLine(statement); //} } //Console.WriteLine(keyValPair.Key); //Console.WriteLine(put); //Console.WriteLine(put.GetType()); } } }
protected TypeCastingLikeExpressionSelector(SyntaxKind?kind) : base(kind) { }
private static void AnalyzeArgumentListIdentifier( IdentifierNameSyntax identifier, SyntaxNodeAnalysisContext context, Dictionary <string, IdentifierNameSyntax> firstVarInitializerSyntax, Dictionary <string, IdentifierNameSyntax> firstVarUsageSyntax, Dictionary <string, IdentifierNameSyntax> firstRecordChangeSyntax, NavTypeKind variableNavTypeKind) { // ISSUE: variable of a compiler-generated type ArgumentListSyntax parent = (ArgumentListSyntax)identifier.Parent; if (!parent.Parent.IsKind(SyntaxKind.InvocationExpression)) { return; } if (((InvocationExpressionSyntax)parent.Parent).Expression.IsKind(SyntaxKind.IdentifierName) && SemanticFacts.IsSameName(((SimpleNameSyntax)((InvocationExpressionSyntax)parent.Parent).Expression).Identifier.ValueText, "evaluate")) { SeparatedSyntaxList <CodeExpressionSyntax> arguments = parent.Arguments; if (arguments[0].IsKind(SyntaxKind.IdentifierName)) { arguments = parent.Arguments; SyntaxToken identifier1 = ((SimpleNameSyntax)arguments[0]).Identifier; string valueText1 = identifier1.ValueText; identifier1 = identifier.Identifier; string valueText2 = identifier1.ValueText; if (SemanticFacts.IsSameName(valueText1, valueText2)) { firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier); SyntaxKind?kind = identifier.Parent?.Parent?.Parent?.Kind; if (!kind.HasValue) { return; } SyntaxKind valueOrDefault = kind.GetValueOrDefault(); if ((uint)valueOrDefault <= 235U) { if (valueOrDefault != SyntaxKind.IfStatement && valueOrDefault != SyntaxKind.ExitStatement) { return; } } else { switch (valueOrDefault) { case SyntaxKind.LogicalOrExpression: case SyntaxKind.LogicalAndExpression: case SyntaxKind.LogicalXorExpression: case SyntaxKind.UnaryNotExpression: break; default: return; } } firstVarUsageSyntax.AddIdentifierIfNotExist(identifier); return; } } firstVarUsageSyntax.AddIdentifierIfNotExist(identifier); } else { IInvocationExpression operation = (IInvocationExpression)context.SemanticModel.GetOperation(parent.Parent); if (operation == null) { if (parent.Arguments.Count == 0) { return; } firstVarUsageSyntax.AddIdentifierIfNotExist(identifier); } else { if (operation.TargetMethod.MethodKind == MethodKind.BuiltInMethod && SemanticFacts.IsSameName(operation.TargetMethod.Name, "settable")) { firstRecordChangeSyntax.AddIdentifierIfNotExist(identifier); } foreach (IArgument obj in operation.Arguments) { if (obj.Value.Syntax == identifier) { if (obj.Parameter != null) { if (obj.Parameter.IsVar) { firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier); if (variableNavTypeKind == NavTypeKind.Record) { firstRecordChangeSyntax.AddIdentifierIfNotExist(identifier); break; } firstVarUsageSyntax.AddIdentifierIfNotExist(identifier); break; } if (obj.Parameter.IsMemberReference) { break; } } if (variableNavTypeKind == NavTypeKind.Record) { break; } firstVarUsageSyntax.AddIdentifierIfNotExist(identifier); break; } } } } }
private SyntaxToken LexDirectiveToken() { _kind = SyntaxKind.BadToken; _contextualKind = SyntaxKind.BadToken; _diagnostics.Clear(); _start = _charReader.Position; var trailingTrivia = new List <SyntaxNode>(); var isEndOfLine = false; switch (_charReader.Current) { case '#': NextChar(); if (_charReader.Current == '#') { NextChar(); _kind = SyntaxKind.HashHashToken; } else { _kind = SyntaxKind.HashToken; _currentDirectiveKind = null; } break; case '\r': case '\n': _kind = SyntaxKind.EndOfDirectiveToken; _currentDirectiveKind = null; isEndOfLine = true; break; case '\0': _kind = SyntaxKind.EndOfDirectiveToken; _currentDirectiveKind = null; break; case '<': if (_currentDirectiveKind != SyntaxKind.IncludeKeyword) { goto default; } ReadBracketedString(); break; default: ReadToken(); if (_contextualKind.IsPreprocessorDirective()) { _currentDirectiveKind = _contextualKind; } break; } var end = _charReader.Position; var kind = _kind; var span = TextSpan.FromBounds(Text.Filename, _start, end); var text = Text.GetText(span); var diagnostics = _diagnostics.ToImmutableArray(); LexDirectiveTrailingTrivia(trailingTrivia, kind, isEndOfLine); var token = new SyntaxToken(kind, _contextualKind, false, MakeAbsolute(span), span, text, _value, ImmutableArray <SyntaxNode> .Empty, trailingTrivia.ToImmutableArray(), diagnostics, null, false); return(token); }
private static SyntaxTokenList TokenList(SyntaxKind?modifier) { return(modifier == null?Syntax.TokenList() : Syntax.TokenList(Syntax.Token(modifier.Value))); }