private static BlockSyntax GenerateBlock(IMethodSymbol accessor) { return(SyntaxFactory.Block( StatementGenerator.GenerateStatements(CodeGenerationMethodInfo.GetStatements(accessor)))); }
// For the purposes of SemanticModel, it is convenient to have an AliasSymbol for the "global" namespace that "global::" binds // to. This alias symbol is returned only when binding "global::" (special case code). internal static AliasSymbol CreateGlobalNamespaceAlias(NamespaceSymbol globalNamespace, Binder globalNamespaceBinder) { SyntaxToken aliasName = SyntaxFactory.Identifier(SyntaxFactory.TriviaList(), SyntaxKind.GlobalKeyword, "global", "global", SyntaxFactory.TriviaList()); return(new AliasSymbol(globalNamespaceBinder, globalNamespace, aliasName, ImmutableArray <Location> .Empty)); }
public InterpolatedStringExpressionSyntax ToInterpolatedString() { var sb = new StringBuilder(); sb.Append('$'); if (!ContainsRegular) { sb.Append('@'); } sb.Append('"'); for (int i = 0; i < Expressions.Length; i++) { SyntaxKind kind = Expressions[i].Kind(); if (kind == SyntaxKind.StringLiteralExpression) { var literal = (LiteralExpressionSyntax)Expressions[i]; if (ContainsRegular && ContainsVerbatimLiteral && literal.IsVerbatimStringLiteral()) { string s = literal.Token.ValueText; s = EscapeQuote(s); s = DoubleBraces(s); sb.Append(s); } else { string s = GetInnerText(literal.Token.Text); s = DoubleBraces(s); sb.Append(s); } } else if (kind == SyntaxKind.InterpolatedStringExpression) { var interpolatedString = (InterpolatedStringExpressionSyntax)Expressions[i]; bool isVerbatimInterpolatedString = interpolatedString.IsVerbatim(); foreach (InterpolatedStringContentSyntax content in interpolatedString.Contents) { SyntaxKind contentKind = content.Kind(); Debug.Assert(content.IsKind(SyntaxKind.Interpolation, SyntaxKind.InterpolatedStringText), content.Kind().ToString()); if (contentKind == SyntaxKind.InterpolatedStringText) { var text = (InterpolatedStringTextSyntax)content; if (ContainsRegular && isVerbatimInterpolatedString) { string s = text.TextToken.ValueText; s = EscapeQuote(s); sb.Append(s); } else { sb.Append(content.ToString()); } } else if (contentKind == SyntaxKind.Interpolation) { sb.Append(content.ToString()); } } } else { sb.Append('{'); sb.Append(Expressions[i].ToString()); sb.Append('}'); } } sb.Append("\""); return((InterpolatedStringExpressionSyntax)SyntaxFactory.ParseExpression(sb.ToString())); }
/// <summary> /// Injects an if statement with the original code or the mutated one, depending on condition's result. /// </summary> /// <param name="condition">Expression for the condition.</param> /// <param name="originalNode">Original code</param> /// <param name="mutatedNode">Mutated code</param> /// <returns>A statement containing the expected construct.</returns> /// <remarks>This method works with statement and block.</remarks> public IfStatementSyntax InjectIf(ExpressionSyntax condition, StatementSyntax originalNode, StatementSyntax mutatedNode) => SyntaxFactory.IfStatement(condition, AsBlock(mutatedNode), SyntaxFactory.ElseClause(AsBlock(originalNode))).WithAdditionalAnnotations(Marker);
/// <summary> /// Finds the local function, anonymous function, method, accessor, or ctor that most directly owns a given syntax node. /// </summary> /// <param name="syntaxNode">The syntax node to begin the search from.</param> /// <returns>The containing function, and metadata for it.</returns> internal static ContainingFunctionData GetContainingFunction(CSharpSyntaxNode syntaxNode) { while (syntaxNode != null) { if (syntaxNode is SimpleLambdaExpressionSyntax simpleLambda) { return(new ContainingFunctionData(simpleLambda, simpleLambda.AsyncKeyword != default(SyntaxToken), SyntaxFactory.ParameterList().AddParameters(simpleLambda.Parameter), simpleLambda.Body)); } if (syntaxNode is AnonymousMethodExpressionSyntax anonymousMethod) { return(new ContainingFunctionData(anonymousMethod, anonymousMethod.AsyncKeyword != default(SyntaxToken), anonymousMethod.ParameterList, anonymousMethod.Body)); } if (syntaxNode is ParenthesizedLambdaExpressionSyntax lambda) { return(new ContainingFunctionData(lambda, lambda.AsyncKeyword != default(SyntaxToken), lambda.ParameterList, lambda.Body)); } if (syntaxNode is AccessorDeclarationSyntax accessor) { return(new ContainingFunctionData(accessor, false, SyntaxFactory.ParameterList(), accessor.Body)); } if (syntaxNode is BaseMethodDeclarationSyntax method) { return(new ContainingFunctionData(method, method.Modifiers.Any(SyntaxKind.AsyncKeyword), method.ParameterList, method.Body)); } syntaxNode = (CSharpSyntaxNode)syntaxNode.Parent; } return(default(ContainingFunctionData)); }
private static BlockSyntax CallNativePointerOverload(MethodDeclarationSyntax nativePointerOverload, GeneratorFlags flags, IReadOnlyDictionary <ParameterSyntax, FriendlyFlags> parametersToFriendlyTransform) { Func <ParameterSyntax, IdentifierNameSyntax> getLocalSubstituteName = p => SyntaxFactory.IdentifierName(p.Identifier.ValueText + "Local"); var invocationArguments = new Dictionary <ParameterSyntax, ArgumentSyntax>(); foreach (var p in nativePointerOverload.ParameterList.Parameters) { var refOrOut = p.Modifiers.FirstOrDefault(m => m.IsKind(SyntaxKind.RefKeyword) || m.IsKind(SyntaxKind.OutKeyword)); invocationArguments[p] = SyntaxFactory .Argument(SyntaxFactory.IdentifierName(p.Identifier)) .WithRefOrOutKeyword(refOrOut); } var prelude = new List <StatementSyntax>(); var postlude = new List <StatementSyntax>(); var fixedStatements = new List <FixedStatementSyntax>(); foreach (var parameter in nativePointerOverload.ParameterList.Parameters.Where(p => p.Type is PointerTypeSyntax)) { var parameterName = SyntaxFactory.IdentifierName(parameter.Identifier); var localVarName = getLocalSubstituteName(parameter); FriendlyFlags friendlyFlags; if (flags.HasFlag(GeneratorFlags.NativePointerToFriendly) && parametersToFriendlyTransform.TryGetValue(parameter, out friendlyFlags)) { if (friendlyFlags.HasFlag(FriendlyFlags.Array)) { var fixedArrayDecl = SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause(parameterName)); fixedStatements.Add(SyntaxFactory.FixedStatement( SyntaxFactory.VariableDeclaration(parameter.Type).AddVariables(fixedArrayDecl), SyntaxFactory.Block())); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } else { if (friendlyFlags.HasFlag(FriendlyFlags.Optional)) { var nullableType = (PointerTypeSyntax)parameter.Type; var hasValueExpression = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(Nullable <int> .HasValue))); var valueExpression = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(Nullable <int> .Value))); var defaultExpression = SyntaxFactory.DefaultExpression(nullableType.ElementType); var varStatement = SyntaxFactory.VariableDeclaration(nullableType.ElementType).AddVariables( SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause( SyntaxFactory.ConditionalExpression( hasValueExpression, valueExpression, defaultExpression)))); prelude.Add(SyntaxFactory.LocalDeclarationStatement(varStatement)); if (friendlyFlags.HasFlag(FriendlyFlags.Out)) { // someParam = someParamLocal; var assignBackToParameter = SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, parameterName, localVarName); var conditionalStatement = SyntaxFactory.IfStatement( hasValueExpression, SyntaxFactory.ExpressionStatement(assignBackToParameter)); postlude.Add(conditionalStatement); } invocationArguments[parameter] = invocationArguments[parameter].WithExpression( SyntaxFactory.ConditionalExpression( hasValueExpression, SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AddressOfExpression, localVarName), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); } else if (friendlyFlags.HasFlag(FriendlyFlags.Out)) { var fixedDecl = SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause( SyntaxFactory.PrefixUnaryExpression( SyntaxKind.AddressOfExpression, parameterName))); fixedStatements.Add(SyntaxFactory.FixedStatement( SyntaxFactory.VariableDeclaration(parameter.Type).AddVariables(fixedDecl), SyntaxFactory.Block())); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } else { invocationArguments[parameter] = invocationArguments[parameter] .WithExpression(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AddressOfExpression, parameterName)); } } } else if (flags.HasFlag(GeneratorFlags.NativePointerToIntPtr)) { var varStatement = SyntaxFactory.VariableDeclaration(parameter.Type); var declarator = SyntaxFactory.VariableDeclarator(localVarName.Identifier); if (parameter.Modifiers.Any(m => m.IsKind(SyntaxKind.OutKeyword))) { var assignment = SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, parameterName, SyntaxFactory.ObjectCreationExpression( IntPtrTypeSyntax, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(localVarName))), null)); postlude.Add(SyntaxFactory.ExpressionStatement(assignment)); } else { var voidStarPointer = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(IntPtr.ToPointer))), SyntaxFactory.ArgumentList()); var typedPointer = parameter.Type.Equals(VoidStar) ? (ExpressionSyntax)voidStarPointer : SyntaxFactory.CastExpression(parameter.Type, voidStarPointer); declarator = declarator.WithInitializer(SyntaxFactory.EqualsValueClause(typedPointer)); } varStatement = varStatement.AddVariables(declarator); prelude.Add(SyntaxFactory.LocalDeclarationStatement(varStatement)); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } } var invocationExpression = SyntaxFactory.InvocationExpression( SyntaxFactory.IdentifierName(nativePointerOverload.Identifier.ValueText), SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList( from p in nativePointerOverload.ParameterList.Parameters select invocationArguments[p]))); IdentifierNameSyntax resultVariableName = null; StatementSyntax invocationStatement; if (nativePointerOverload.ReturnType != null && (nativePointerOverload.ReturnType as PredefinedTypeSyntax)?.Keyword.Kind() != SyntaxKind.VoidKeyword) { resultVariableName = SyntaxFactory.IdentifierName("result"); // TODO: ensure this is unique. invocationStatement = SyntaxFactory.LocalDeclarationStatement( SyntaxFactory.VariableDeclaration(nativePointerOverload.ReturnType) .AddVariables( SyntaxFactory.VariableDeclarator(resultVariableName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause(invocationExpression)))); } else { invocationStatement = SyntaxFactory.ExpressionStatement(invocationExpression); } var block = SyntaxFactory.Block() .AddStatements(prelude.ToArray()) .AddStatements(invocationStatement) .AddStatements(postlude.ToArray()); if (resultVariableName != null) { ExpressionSyntax returnedValue = nativePointerOverload.ReturnType is PointerTypeSyntax ? (ExpressionSyntax)SyntaxFactory.ObjectCreationExpression( IntPtrTypeSyntax, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(resultVariableName))), null) : resultVariableName; block = block.AddStatements(SyntaxFactory.ReturnStatement(returnedValue)); } if (fixedStatements.Count > 0) { StatementSyntax outermost = block; foreach (var statement in fixedStatements) { outermost = statement.WithStatement(outermost); } block = SyntaxFactory.Block(outermost); } return(block); }
/// <summary> /// injects a 'using' block with static marker class used by coverage logic. /// </summary> /// <param name="block"></param> /// <returns></returns> public BlockSyntax PlaceStaticContextMarker(BlockSyntax block) => SyntaxFactory.Block( SyntaxFactory.UsingStatement(null, CodeInjection.GetContextClassConstructor(), block)).WithAdditionalAnnotations(Marker);
private TypeSyntax ParseTypeName(string text) { return(SyntaxFactory.ParseTypeName(text)); }
public void TestFormattingCharacter() { var text = "\u0915\u094d\u200d\u0937"; var tok = SyntaxFactory.ParseToken(text); Assert.NotEqual(default, tok);
private bool TryRemoveSummaryPrefix(ref SyntaxList <XmlNodeSyntax> summaryContent, string prefix) { XmlNodeSyntax firstContent = summaryContent.FirstOrDefault(IsContentElement); if (!(firstContent is XmlTextSyntax firstText)) { return(false); } string firstTextContent = string.Concat(firstText.DescendantTokens()); if (!firstTextContent.TrimStart().StartsWith(prefix, StringComparison.Ordinal)) { return(false); } // Find the token containing the prefix, such as "Gets or sets " SyntaxToken prefixToken = default; foreach (SyntaxToken textToken in firstText.TextTokens) { if (textToken.IsMissing) { continue; } if (!textToken.Text.TrimStart().StartsWith(prefix, StringComparison.Ordinal)) { continue; } prefixToken = textToken; break; } if (prefixToken.IsMissingOrDefault()) { return(false); } string text = prefixToken.Text; string valueText = prefixToken.ValueText; int index = text.IndexOf(prefix); if (index >= 0) { bool additionalCharacters = index + prefix.Length < text.Length; text = text.Substring(0, index) + (additionalCharacters ? char.ToUpperInvariant(text[index + prefix.Length]).ToString() : string.Empty) + text.Substring(index + (additionalCharacters ? (prefix.Length + 1) : prefix.Length)); } index = valueText.IndexOf(prefix); if (index >= 0) { valueText = valueText.Remove(index, prefix.Length); } SyntaxToken replaced = SyntaxFactory.Token(prefixToken.LeadingTrivia, prefixToken.Kind(), text, valueText, prefixToken.TrailingTrivia); summaryContent = summaryContent.Replace(firstText, firstText.ReplaceToken(prefixToken, replaced)); return(true); }
static ITypeSymbol CreateClass(MonoDevelop.Projects.Project project, Stetic.ActionGroupComponent group, string name, string namspace, string folder) { string fullName = namspace.Length > 0 ? namspace + "." + name : name; var type = SyntaxFactory.ClassDeclaration(name) .AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("Gtk.ActionGroup"))); // Generate the constructor. It contains the call that builds the widget. var members = new SyntaxList <MemberDeclarationSyntax> (); var ctor = SyntaxFactory.ConstructorDeclaration( new SyntaxList <AttributeListSyntax> (), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), SyntaxFactory.Identifier(name), SyntaxFactory.ParameterList(), SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseKeyword, SyntaxFactory.ArgumentList(new SeparatedSyntaxList <ArgumentSyntax> { SyntaxFactory.Argument(SyntaxFactory.ParseExpression(fullName)) })), SyntaxFactory.Block( SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.ParseExpression("Stetic.Gui.Build"), SyntaxFactory.ArgumentList( new SeparatedSyntaxList <ArgumentSyntax> { SyntaxFactory.Argument(SyntaxFactory.ThisExpression()), SyntaxFactory.Argument(SyntaxFactory.ParseExpression(fullName)) } ) ) ) ) ); type = type.AddMembers(ctor); // Add signal handlers foreach (Stetic.ActionComponent action in group.GetActions()) { foreach (Stetic.Signal signal in action.GetSignals()) { var parameters = new SeparatedSyntaxList <ParameterSyntax> (); foreach (var p in signal.SignalDescriptor.HandlerParameters) { parameters = parameters.Add(SyntaxFactory.Parameter(new SyntaxList <AttributeListSyntax> (), SyntaxFactory.TokenList(), SyntaxFactory.ParseTypeName(p.TypeName), SyntaxFactory.Identifier(p.Name), null)); } var met = SyntaxFactory.MethodDeclaration( new SyntaxList <AttributeListSyntax> (), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)), SyntaxFactory.ParseTypeName(signal.SignalDescriptor.HandlerReturnTypeName), null, SyntaxFactory.Identifier(signal.Handler), null, SyntaxFactory.ParameterList(parameters), new SyntaxList <TypeParameterConstraintClauseSyntax> (), SyntaxFactory.Block(), null ); type = type.AddMembers(met); } } // Create the class return(CodeGenerationService.AddType((DotNetProject)project, folder, namspace, type)); }
private static InvocationExpressionSyntax BuildCorrectCheckThatExpression( ExpressionSyntax invocationExpression, ITypeSymbol sutType) { var checkName = string.Empty; // deal with well known types switch (sutType.SpecialType) { case SpecialType.System_Boolean: checkName = "IsTrue"; // When we have a reference type break; case SpecialType.System_String: checkName = "IsNotEmpty"; break; case SpecialType.System_Enum: break; case SpecialType.System_SByte: case SpecialType.System_Byte: case SpecialType.System_Int16: case SpecialType.System_UInt16: case SpecialType.System_Int32: case SpecialType.System_UInt32: case SpecialType.System_Int64: case SpecialType.System_UInt64: case SpecialType.System_Decimal: case SpecialType.System_Single: case SpecialType.System_Double: checkName = "IsNotZero"; break; case SpecialType.System_DateTime: break; case SpecialType.System_IAsyncResult: break; case SpecialType.System_AsyncCallback: break; default: if (sutType.TypeKind == TypeKind.Array || sutType.AllInterfaces.Any(t => t.SpecialType == SpecialType.System_Collections_IEnumerable)) { return SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, invocationExpression, SyntaxFactory.IdentifierName("Not")), SyntaxFactory.IdentifierName("IsEmpty"))); } if (sutType.IsReferenceType || sutType.OriginalDefinition?.SpecialType == SpecialType.System_Nullable_T) { checkName = "IsNotNull"; } break; } InvocationExpressionSyntax replacementNode; if (!string.IsNullOrEmpty(checkName)) { // no fix applied replacementNode = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, invocationExpression, SyntaxFactory.IdentifierName(checkName))); } else { replacementNode = null; } return replacementNode; }
protected override bool TryInitializeSimpleAttributeNameGenerationState( SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken, out SyntaxToken token, out IList <ArgumentSyntax> arguments, out IList <AttributeArgumentSyntax> attributeArguments, out INamedTypeSymbol typeToGenerateIn) { var simpleName = (SimpleNameSyntax)node; var fullName = simpleName.IsRightSideOfQualifiedName() ? (NameSyntax)simpleName.Parent : simpleName; if (fullName.Parent is AttributeSyntax) { var attribute = (AttributeSyntax)fullName.Parent; if (attribute.ArgumentList != null && !attribute.ArgumentList.CloseParenToken.IsMissing) { var symbolInfo = document.SemanticModel.GetSymbolInfo(attribute, cancellationToken); if (symbolInfo.CandidateReason == CandidateReason.OverloadResolutionFailure && !symbolInfo.CandidateSymbols.IsEmpty) { token = simpleName.Identifier; attributeArguments = attribute.ArgumentList.Arguments.ToList(); arguments = attributeArguments.Select(x => SyntaxFactory.Argument(x.NameColon ?? ((x.NameEquals != null) ? SyntaxFactory.NameColon(x.NameEquals.Name) : null), default(SyntaxToken), x.Expression)).ToList(); typeToGenerateIn = symbolInfo.CandidateSymbols.FirstOrDefault().ContainingSymbol as INamedTypeSymbol; return(typeToGenerateIn != null); } } } token = default(SyntaxToken); arguments = null; attributeArguments = null; typeToGenerateIn = null; return(false); }
internal override IMethodSymbol GetDelegatingConstructor(State state, SemanticDocument document, int argumentCount, INamedTypeSymbol namedType, ISet <IMethodSymbol> candidates, CancellationToken cancellationToken) { var oldToken = state.Token; var tokenKind = oldToken.Kind(); if (state.IsConstructorInitializerGeneration) { SyntaxToken thisOrBaseKeyword; SyntaxKind newCtorInitializerKind; if (tokenKind != SyntaxKind.BaseKeyword && state.TypeToGenerateIn == namedType) { thisOrBaseKeyword = SyntaxFactory.Token(SyntaxKind.ThisKeyword); newCtorInitializerKind = SyntaxKind.ThisConstructorInitializer; } else { thisOrBaseKeyword = SyntaxFactory.Token(SyntaxKind.BaseKeyword); newCtorInitializerKind = SyntaxKind.BaseConstructorInitializer; } var ctorInitializer = (ConstructorInitializerSyntax)oldToken.Parent; var oldArgumentList = ctorInitializer.ArgumentList; var newArgumentList = GetNewArgumentList(oldArgumentList, argumentCount); var newCtorInitializer = SyntaxFactory.ConstructorInitializer(newCtorInitializerKind, ctorInitializer.ColonToken, thisOrBaseKeyword, newArgumentList); SemanticModel speculativeModel; if (document.SemanticModel.TryGetSpeculativeSemanticModel(ctorInitializer.Span.Start, newCtorInitializer, out speculativeModel)) { var symbolInfo = speculativeModel.GetSymbolInfo(newCtorInitializer, cancellationToken); return(GenerateConstructorHelpers.GetDelegatingConstructor(symbolInfo, candidates, namedType)); } } else { var oldNode = oldToken.Parent .AncestorsAndSelf(ascendOutOfTrivia: false) .Where(node => SpeculationAnalyzer.CanSpeculateOnNode(node)) .LastOrDefault(); var typeNameToReplace = (TypeSyntax)oldToken.Parent; TypeSyntax newTypeName; if (namedType != state.TypeToGenerateIn) { while (true) { var parentType = typeNameToReplace.Parent as TypeSyntax; if (parentType == null) { break; } typeNameToReplace = parentType; } newTypeName = namedType.GenerateTypeSyntax().WithAdditionalAnnotations(annotation); } else { newTypeName = typeNameToReplace.WithAdditionalAnnotations(annotation); } var newNode = oldNode.ReplaceNode(typeNameToReplace, newTypeName); newTypeName = (TypeSyntax)newNode.GetAnnotatedNodes(annotation).Single(); var oldArgumentList = (ArgumentListSyntax)newTypeName.Parent.ChildNodes().FirstOrDefault(n => n is ArgumentListSyntax); if (oldArgumentList != null) { var newArgumentList = GetNewArgumentList(oldArgumentList, argumentCount); if (newArgumentList != oldArgumentList) { newNode = newNode.ReplaceNode(oldArgumentList, newArgumentList); newTypeName = (TypeSyntax)newNode.GetAnnotatedNodes(annotation).Single(); } } var speculativeModel = SpeculationAnalyzer.CreateSpeculativeSemanticModelForNode(oldNode, newNode, document.SemanticModel); if (speculativeModel != null) { var symbolInfo = speculativeModel.GetSymbolInfo(newTypeName.Parent, cancellationToken); return(GenerateConstructorHelpers.GetDelegatingConstructor(symbolInfo, candidates, namedType)); } } return(null); }
private static ParameterListSyntax TransformParameterList(ParameterListSyntax list, GeneratorFlags generatorFlags, IReadOnlyDictionary <ParameterSyntax, FriendlyFlags> parametersToFriendlyTransform) { var resultingList = list.ReplaceNodes( WhereIsPointerParameter(list.Parameters), (n1, n2) => { // Remove all attributes n2 = n2.WithAttributeLists(SyntaxFactory.List <AttributeListSyntax>()); FriendlyFlags friendlyFlags; if (generatorFlags.HasFlag(GeneratorFlags.NativePointerToFriendly) && parametersToFriendlyTransform.TryGetValue(n1, out friendlyFlags)) { var pointerType = (PointerTypeSyntax)n2.Type; var alteredParameter = n2.WithDefault(null); if (friendlyFlags.HasFlag(FriendlyFlags.Array)) { alteredParameter = alteredParameter .WithType(SyntaxFactory.ArrayType(pointerType.ElementType, OneDimensionalUnspecifiedLengthArray)); } else { if (friendlyFlags.HasFlag(FriendlyFlags.Optional)) { alteredParameter = alteredParameter .WithType(SyntaxFactory.NullableType(pointerType.ElementType)); } if (friendlyFlags.HasFlag(FriendlyFlags.Out)) { SyntaxKind modifier = friendlyFlags.HasFlag(FriendlyFlags.Optional) || friendlyFlags.HasFlag(FriendlyFlags.In) ? SyntaxKind.RefKeyword : SyntaxKind.OutKeyword; if (!friendlyFlags.HasFlag(FriendlyFlags.Optional)) { alteredParameter = alteredParameter .WithType(pointerType.ElementType); } alteredParameter = alteredParameter .AddModifiers(SyntaxFactory.Token(modifier)); } else if (!friendlyFlags.HasFlag(FriendlyFlags.Optional)) { alteredParameter = alteredParameter .WithType(pointerType.ElementType); } } return(alteredParameter); } else if (generatorFlags.HasFlag(GeneratorFlags.NativePointerToIntPtr)) { return(n2 .WithType(IntPtrTypeSyntax) .WithDefault(null)); } else { return(n2); } }); return(resultingList); }
private SyntaxNode GetNewBlock(SyntaxNode statement, StatementSyntax statementBody) { var body = SyntaxFactory.Block(statementBody); return(statement.ReplaceNode(statementBody, body)); }
private static SyntaxTokenList RemoveModifier(SyntaxTokenList list, params SyntaxKind[] modifiers) { return(SyntaxFactory.TokenList(list.Where(t => Array.IndexOf(modifiers, t.Kind()) < 0))); }
public override CSharpSyntaxNode VisitModuleDefinition([NotNull] GammerParser.ModuleDefinitionContext context) { var namespaces = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(context.moduleName().GetText()) .WithLeadingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))) .WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.EndOfLineTrivia, "\n"))) ); namespaces = namespaces.AddMembers(SyntaxFactory.ClassDeclaration(" Program").AddMembers(SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName("System.Windows.Forms.Timer"), "Ticker") .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))) .WithInitializer(SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(2)))) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) , SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName("void"), "Main") .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) .WithBody(SyntaxFactory.Block()))); return SyntaxFactory.CompilationUnit().AddMembers(namespaces); }
/// <inheritdoc /> public Task <SyntaxList <MemberDeclarationSyntax> > GenerateAsync(TransformationContext context, IProgress <Diagnostic> progress, CancellationToken cancellationToken) { var applyTo = context.ProcessingNode; var compilation = context.Compilation; var semanticModel = compilation.GetSemanticModel(applyTo.SyntaxTree); var type = (ClassDeclarationSyntax)applyTo; var generatedType = type .WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>()); var methodsWithNativePointers = from method in type.Members.OfType <MethodDeclarationSyntax>() where WhereIsPointerParameter(method.ParameterList.Parameters).Any() || method.ReturnType is PointerTypeSyntax select method; foreach (var method in methodsWithNativePointers) { var nativePointerParameters = method.ParameterList.Parameters.Where(p => p.Type is PointerTypeSyntax); var refOrArrayAttributedParameters = from parameter in nativePointerParameters let attributes = parameter.AttributeLists.SelectMany(al => al.Attributes) let friendlyAttribute = attributes.FirstOrDefault(attribute => (attribute.Name as SimpleNameSyntax)?.Identifier.ValueText == "Friendly") where friendlyAttribute != null let friendlyFlagsExpression = friendlyAttribute.ArgumentList.Arguments.First().Expression let friendlyFlags = (FriendlyFlags)(int)semanticModel.GetConstantValue(friendlyFlagsExpression).Value select new { Parameter = parameter, Flags = friendlyFlags }; var parametersToFriendlyTransform = refOrArrayAttributedParameters.ToDictionary(p => p.Parameter, p => p.Flags); // Consider undecorated byte* parameters to have a Friendly attribute by default. var byteArrayInParameters = nativePointerParameters.Where(IsByteStarInParameter); foreach (var p in byteArrayInParameters) { if (!parametersToFriendlyTransform.ContainsKey(p)) { parametersToFriendlyTransform[p] = FriendlyFlags.Array | FriendlyFlags.Bidirectional; } } var transformedMethodBase = method .WithReturnType(TransformReturnType(method.ReturnType)) .WithIdentifier(TransformMethodName(method)) .WithModifiers(RemoveModifier(method.Modifiers, SyntaxKind.ExternKeyword)) .WithAttributeLists(FilterAttributes(method.AttributeLists)) .WithLeadingTrivia(method.GetLeadingTrivia().Where(t => !t.IsDirective)) .WithTrailingTrivia(method.GetTrailingTrivia().Where(t => !t.IsDirective)) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) .WithExpressionBody(null); var flags = GeneratorFlags.NativePointerToIntPtr; var intPtrOverload = transformedMethodBase .WithParameterList(TransformParameterList(method.ParameterList, flags, parametersToFriendlyTransform)) .WithBody(CallNativePointerOverload(method, flags, parametersToFriendlyTransform)); generatedType = generatedType.AddMembers(intPtrOverload); if (parametersToFriendlyTransform.Count > 0) { flags = GeneratorFlags.NativePointerToIntPtr | GeneratorFlags.NativePointerToFriendly; var byteArrayAndIntPtrOverload = transformedMethodBase .WithParameterList(TransformParameterList(method.ParameterList, flags, parametersToFriendlyTransform)) .WithBody(CallNativePointerOverload(method, flags, parametersToFriendlyTransform)); generatedType = generatedType.AddMembers(byteArrayAndIntPtrOverload); // If there are native pointers that aren't "friendly", it would produce a unique method signature // for a method that only converts the friendly parameters and leaves other native pointers alone. if (nativePointerParameters.Except(parametersToFriendlyTransform.Keys).Any()) { flags = GeneratorFlags.NativePointerToFriendly; var friendlyOverload = transformedMethodBase .WithParameterList(TransformParameterList(method.ParameterList, flags, parametersToFriendlyTransform)) .WithBody(CallNativePointerOverload(method, flags, parametersToFriendlyTransform)); generatedType = generatedType.AddMembers(friendlyOverload); } } } return(Task.FromResult(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(generatedType))); }
public override Microsoft.CodeAnalysis.SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node) { FieldDeclarationSyntax newNode = null; var parent = node.Parent; // Verify we have the correct context for the Field Declaration switch (_declarationLocation) { case SyntaxNode.FieldDeclarationLocation.Class: if (parent.Kind() != SyntaxKind.ClassBlock) { return(node); } break; case SyntaxNode.FieldDeclarationLocation.Module: if (parent.Kind() != SyntaxKind.ModuleBlock) { return(node); } break; case SyntaxNode.FieldDeclarationLocation.Structure: if (parent.Kind() != SyntaxKind.StructureBlock) { return(node); } break; } if (_targetPatternRegEx.Match(node.Declarators.First().Names.First().Identifier.ToString()).Success) { try { // Verify this expression is on line by itself. May not need to do this. // See if can have multiple FieldDeclarations on same line. if (VNCCA.Helpers.VB.IsOnLineByItself(node)) { // HACK(crhodes) // Figure out how to get Helpers to work here. Messages.AppendLine(String.Format("Removing {0} {1}", VNCCA.Helpers.VB.GetContainingContext(node, _configurationOptions), node.ToString())); if (_commentOutOnly) { List <SyntaxTrivia> newTrivia = new List <SyntaxTrivia>(); string existingLeadingTrivia = node.GetLeadingTrivia().ToString(); string existingLeadingTriviaFull = node.GetLeadingTrivia().ToFullString(); string existingTrailingTrivia = node.GetTrailingTrivia().ToString(); string existingTrailingTriviaFull = node.GetTrailingTrivia().ToFullString(); string startOfLineWhiteSpace = existingLeadingTrivia.Replace(System.Environment.NewLine, ""); newTrivia.Add(SyntaxFactory.CommentTrivia(existingLeadingTriviaFull)); newTrivia.Add(SyntaxFactory.CommentTrivia(VNCCA.Helpers.VB.MultiLineComment(_comment, startOfLineWhiteSpace))); newTrivia.Add(SyntaxFactory.CommentTrivia("' ")); newNode = node.WithLeadingTrivia(newTrivia); } else { // This removes the node newNode = null; } } else { Messages.AppendLine(String.Format("node: >{0}< >{1}< Is NOT OnLineByItself", node.ToString(), node.ToFullString())); newNode = node; } } catch (Exception ex) { Messages.AppendLine(string.Format("Ex:{0} InnerEx:{1}", ex.ToString(), ex.InnerException.ToString())); } } else { newNode = node; } return(newNode); }
#pragma warning restore public async Task AppendingUnrelatedSource_DoesNotRegenerateSource() { string source = $"namespace NS{{{CodeSnippets.BasicParametersAndModifiers<int>()}}}"; SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview)); Compilation comp1 = await TestUtils.CreateCompilation(new[] { syntaxTree }); Microsoft.Interop.DllImportGenerator generator = new(); GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, new[] { generator }); driver = driver.RunGenerators(comp1); generator.IncrementalTracker = new IncrementalityTracker(); SyntaxTree newTree = syntaxTree.WithRootAndOptions(syntaxTree.GetCompilationUnitRoot().AddMembers(SyntaxFactory.ParseMemberDeclaration("struct Foo {}") !), syntaxTree.Options); Compilation comp2 = comp1.ReplaceSyntaxTree(comp1.SyntaxTrees.First(), newTree); driver.RunGenerators(comp2); Assert.Collection(generator.IncrementalTracker.ExecutedSteps, step => { Assert.Equal(IncrementalityTracker.StepName.CalculateStubInformation, step.Step); }); }
private IEnumerable<SyntaxTree> GeneratedSyntaxTrees() { yield return SyntaxFactory.ParseSyntaxTree($"[assembly: {typeof(CompiledFromDirectoryAttribute).FullName}(@\"{CurrentDirectory.FullName}\")]", CscArgs.ParseOptions); }
private static BlockSyntax AsBlock(StatementSyntax code) => code as BlockSyntax ?? SyntaxFactory.Block(code);
public static SyntaxToken GetStubDefinitionIdentifier(string originalName) { return(SyntaxFactory.Identifier(originalName + "Def")); }
private SyntaxTree InjectMutationLabel(SyntaxTree syntaxTree) { var root = syntaxTree.GetRoot(); var myAttribute = ((CompilationUnitSyntax)root).AttributeLists .SelectMany(al => al.Attributes).FirstOrDefault(n => n.Name.Kind() == SyntaxKind.QualifiedName && ((QualifiedNameSyntax)n.Name).Right .Kind() == SyntaxKind.IdentifierName && (string)((IdentifierNameSyntax)((QualifiedNameSyntax)n.Name).Right) .Identifier.Value == "AssemblyTitleAttribute"); var labelNode = myAttribute?.ArgumentList.Arguments.First()?.Expression; var newLabel = string.Empty; if (labelNode != null && labelNode.Kind() == SyntaxKind.StringLiteralExpression) { var literal = (LiteralExpressionSyntax)labelNode; newLabel = $"Mutated {literal.Token.Value}"; } if (myAttribute != null) { var newAttribute = myAttribute.ReplaceNode(labelNode, SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(newLabel))); root = root.ReplaceNode(myAttribute, newAttribute); return(root.SyntaxTree); } return(syntaxTree); }
public static IdentifierNameSyntax GetStubDefinitionIdentifierName(string originalName) { return(SyntaxFactory.IdentifierName(originalName + "Def")); }
private IView GenerateExecutableCоde(string csharpCode, object viewModel) { var compileResult = CSharpCompilation.Create("ViewAssembly") .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)) .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)) .AddReferences(MetadataReference.CreateFromFile(typeof(IView).Assembly.Location)); if (viewModel != null) { if (viewModel.GetType().IsGenericType) { var genericArguments = viewModel.GetType().GenericTypeArguments; foreach (var genericArgument in genericArguments) { compileResult = compileResult .AddReferences(MetadataReference.CreateFromFile(genericArgument.Assembly.Location)); } } compileResult = compileResult .AddReferences(MetadataReference.CreateFromFile(viewModel.GetType().Assembly.Location)); } var libraries = Assembly.Load(new AssemblyName("netstandard")) .GetReferencedAssemblies(); foreach (var library in libraries) { compileResult = compileResult .AddReferences(MetadataReference.CreateFromFile( Assembly.Load(library).Location)); } compileResult = compileResult.AddSyntaxTrees(SyntaxFactory.ParseSyntaxTree(csharpCode)); using (MemoryStream memoryStream = new MemoryStream()) { EmitResult result = compileResult.Emit(memoryStream); if (!result.Success) { return(new ErrorView(result.Diagnostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => x.GetMessage()), csharpCode)); } try { memoryStream.Seek(0, SeekOrigin.Begin); var byteAssembly = memoryStream.ToArray(); var assembly = Assembly.Load(byteAssembly); var viewType = assembly.GetType("ViewNamespace.ViewClass"); var instance = Activator.CreateInstance(viewType); return((instance as IView) ?? new ErrorView(new List <string> { "Instance is null!" }, csharpCode)); } catch (Exception ex) { return(new ErrorView(new List <string> { ex.ToString() }, csharpCode)); } } }
private static PrefixUnaryExpressionSyntax NegateCondition(ExpressionSyntax expressionSyntax) { return(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, SyntaxFactory.ParenthesizedExpression(expressionSyntax))); }
public void MutantPlacer_ShouldPlaceWithIfStatement(int id) { // 1 + 8; var originalNode = SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)), SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8)))); // 1 - 8; var mutatedNode = SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)), SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8)))); var result = MutantPlacer.PlaceWithIfStatement(originalNode, mutatedNode, id); result.ToFullString().ShouldBeSemantically("if (" + CodeInjection.HelperNamespace + ".MutantControl.IsActive(" + id + @")) { 1 - 8; } else { 1 + 8; }"); var removedResult = MutantPlacer.RemoveMutant(result); removedResult.ToString().ShouldBeSemantically(originalNode.ToString()); }
private static AccessorDeclarationSyntax GenerateAccessorDeclaration( IMethodSymbol accessor, SyntaxKind kind, bool hasBody) { return(AddAnnotationsTo(accessor, SyntaxFactory.AccessorDeclaration(kind) .WithBody(hasBody ? GenerateBlock(accessor) : null) .WithSemicolonToken(hasBody ? default(SyntaxToken) : SyntaxFactory.Token(SyntaxKind.SemicolonToken)))); }