private static SyntaxNode AddGeneratedHandlerMethodToSolution( SemanticDocument document, CSharpCodeGenerationOptions options, string eventHandlerMethodName, SyntaxAnnotation plusEqualsTokenAnnotation, CancellationToken cancellationToken) { var root = document.Root; var eventHookupExpression = root.GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation).Single().AsToken().GetAncestor <AssignmentExpressionSyntax>(); var typeDecl = eventHookupExpression.GetAncestor <TypeDeclarationSyntax>(); var generatedMethodSymbol = GetMethodSymbol(document, eventHandlerMethodName, eventHookupExpression, cancellationToken); if (generatedMethodSymbol == null) { return(null); } var container = (SyntaxNode)typeDecl ?? eventHookupExpression.GetAncestor <CompilationUnitSyntax>(); var codeGenerator = document.Document.GetRequiredLanguageService <ICodeGenerationService>(); var codeGenOptions = options.GetInfo(new CodeGenerationContext(afterThisLocation: eventHookupExpression.GetLocation()), document.Project); var newContainer = codeGenerator.AddMethod(container, generatedMethodSymbol, codeGenOptions, cancellationToken); return(root.ReplaceNode(container, newContainer)); }
public ExpressionCodeGenerator( InsertionPoint insertionPoint, SelectionResult selectionResult, AnalyzerResult analyzerResult, CSharpCodeGenerationOptions options, bool localFunction) : base(insertionPoint, selectionResult, analyzerResult, options, localFunction) { }
public MultipleStatementsCodeGenerator( InsertionPoint insertionPoint, SelectionResult selectionResult, AnalyzerResult analyzerResult, CSharpCodeGenerationOptions options, bool localFunction) : base(insertionPoint, selectionResult, analyzerResult, options, localFunction) { }
public MultipleStatementsCodeGenerator( InsertionPoint insertionPoint, SelectionResult selectionResult, AnalyzerResult analyzerResult, CSharpCodeGenerationOptions options, NamingStylePreferencesProvider namingPreferences, bool localFunction) : base(insertionPoint, selectionResult, analyzerResult, options, namingPreferences, localFunction) { }
public static SyntaxNode ConvertMethodsToProperty( CSharpCodeGenerationOptions options, LanguageVersion languageVersion, SemanticModel semanticModel, SyntaxGenerator generator, GetAndSetMethods getAndSetMethods, string propertyName, bool nameChanged) { var propertyDeclaration = ConvertMethodsToPropertyWorker( options, languageVersion, semanticModel, generator, getAndSetMethods, propertyName, nameChanged); var expressionBodyPreference = options.PreferExpressionBodiedProperties.Value; if (expressionBodyPreference != ExpressionBodyPreference.Never) { if (propertyDeclaration.AccessorList?.Accessors.Count == 1 && propertyDeclaration.AccessorList?.Accessors[0].Kind() == SyntaxKind.GetAccessorDeclaration) { var getAccessor = propertyDeclaration.AccessorList.Accessors[0]; if (getAccessor.ExpressionBody != null) { return(propertyDeclaration.WithExpressionBody(getAccessor.ExpressionBody) .WithSemicolonToken(getAccessor.SemicolonToken) .WithAccessorList(null)); } else if (getAccessor.Body != null && getAccessor.Body.TryConvertToArrowExpressionBody( propertyDeclaration.Kind(), languageVersion, expressionBodyPreference, out var arrowExpression, out var semicolonToken)) { return(propertyDeclaration.WithExpressionBody(arrowExpression) .WithSemicolonToken(semicolonToken) .WithAccessorList(null)); } } } else { if (propertyDeclaration.ExpressionBody != null && propertyDeclaration.ExpressionBody.TryConvertToBlock( propertyDeclaration.SemicolonToken, createReturnStatementForExpression: true, block: out var block)) { var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithBody(block); var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(accessor)); return(propertyDeclaration.WithAccessorList(accessorList) .WithExpressionBody(null) .WithSemicolonToken(default));
private static Diagnostic?AnalyzeSyntax( CSharpCodeGenerationOptions options, SyntaxNode declaration, UseExpressionBodyHelper helper) { var preference = helper.GetExpressionBodyPreference(options); var severity = preference.Notification.Severity; if (helper.CanOfferUseExpressionBody(preference, declaration, forAnalyzer: true)) { var location = severity.WithDefaultSeverity(DiagnosticSeverity.Hidden) == ReportDiagnostic.Hidden ? declaration.GetLocation() : helper.GetDiagnosticLocation(declaration); var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); var properties = ImmutableDictionary <string, string?> .Empty.Add(nameof(UseExpressionBody), ""); return(DiagnosticHelper.Create( CreateDescriptorWithId(helper.DiagnosticId, helper.EnforceOnBuild, helper.UseExpressionBodyTitle, helper.UseExpressionBodyTitle), location, severity, additionalLocations: additionalLocations, properties: properties)); } if (helper.CanOfferUseBlockBody(preference, declaration, forAnalyzer: true, out var fixesError, out var expressionBody)) { // They have an expression body. Create a diagnostic to convert it to a block // if they don't want expression bodies for this member. var location = severity.WithDefaultSeverity(DiagnosticSeverity.Hidden) == ReportDiagnostic.Hidden ? declaration.GetLocation() : expressionBody.GetLocation(); var properties = ImmutableDictionary <string, string?> .Empty; if (fixesError) { properties = properties.Add(FixesError, ""); } var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); return(DiagnosticHelper.Create( CreateDescriptorWithId(helper.DiagnosticId, helper.EnforceOnBuild, helper.UseBlockBodyTitle, helper.UseBlockBodyTitle), location, severity, additionalLocations: additionalLocations, properties: properties)); } return(null); }
public abstract CodeStyleOption2 <ExpressionBodyPreference> GetExpressionBodyPreference(CSharpCodeGenerationOptions options);
public async Task <MetadataAsSourceFile> GenerateSourceAsync( string?symbolMetadataName = null, Project?project = null, bool signaturesOnly = true, bool fileScopedNamespaces = false) { symbolMetadataName ??= AbstractMetadataAsSourceTests.DefaultSymbolMetadataName; project ??= this.DefaultProject; // Get an ISymbol corresponding to the metadata name var compilation = await project.GetRequiredCompilationAsync(CancellationToken.None); var diagnostics = compilation.GetDiagnostics().ToArray(); Assert.Equal(0, diagnostics.Length); var symbol = await ResolveSymbolAsync(symbolMetadataName, compilation); Contract.ThrowIfNull(symbol); if (!signaturesOnly) { foreach (var reference in compilation.References) { if (AssemblyResolver.TestAccessor.ContainsInMemoryImage(reference)) { continue; } if (reference is PortableExecutableReference portableExecutable) { Assert.True(File.Exists(portableExecutable.FilePath), $"'{portableExecutable.FilePath}' does not exist for reference '{portableExecutable.Display}'"); Assert.True(Path.IsPathRooted(portableExecutable.FilePath), $"'{portableExecutable.FilePath}' is not a fully-qualified file name"); } else { Assert.True(File.Exists(reference.Display), $"'{reference.Display}' does not exist"); Assert.True(Path.IsPathRooted(reference.Display), $"'{reference.Display}' is not a fully-qualified file name"); } } } var options = MetadataAsSourceOptions.GetDefault(project.LanguageServices); if (fileScopedNamespaces) { options = options with { GenerationOptions = options.GenerationOptions with { GenerationOptions = new CSharpCodeGenerationOptions { NamespaceDeclarations = new CodeStyleOption2 <NamespaceDeclarationPreference>(NamespaceDeclarationPreference.FileScoped, NotificationOption2.Silent) } } }; } // Generate and hold onto the result so it can be disposed of with this context var result = await _metadataAsSourceService.GetGeneratedFileAsync(project, symbol, signaturesOnly, options); return(result); }