protected override OperationStatus <IMethodSymbol> GenerateMethodDefinition(CancellationToken cancellationToken) { var result = CreateMethodBody(cancellationToken); var methodSymbol = CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: SpecializedCollections.EmptyList <AttributeData>(), accessibility: Accessibility.Private, modifiers: CreateMethodModifiers(), returnType: this.AnalyzerResult.ReturnType, explicitInterfaceSymbol: null, name: _methodName.ToString(), typeParameters: CreateMethodTypeParameters(cancellationToken), parameters: CreateMethodParameters(), statements: result.Data); return(result.With( this.MethodDefinitionAnnotation.AddAnnotationToSymbol( Formatter.Annotation.AddAnnotationToSymbol(methodSymbol)))); }
public void TestThrowsOnGenerateNamespace() { var namespaceSymbol = CodeGenerationSymbolFactory.CreateNamespaceSymbol("Outerspace"); using (var context = new TestContext()) { Assert.Throws <ArgumentException>(() => { try { context.GenerateSource(namespaceSymbol); } catch (AggregateException ae) { throw ae.InnerException; } }); } }
private static IMethodSymbol GenerateMethodSymbol(INamedTypeSymbol typeToGenerateIn, INamedTypeSymbol parameterSymbol) { // Remove any generic parameters if (typeToGenerateIn.IsGenericType) { typeToGenerateIn = typeToGenerateIn.ConstructUnboundGenericType().ConstructedFrom; } return(CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: SpecializedCollections.EmptyList <AttributeData>(), accessibility: default(Accessibility), modifiers: default(DeclarationModifiers), returnType: typeToGenerateIn, explicitInterfaceSymbol: null, name: null, typeParameters: SpecializedCollections.EmptyList <ITypeParameterSymbol>(), parameters: new[] { CodeGenerationSymbolFactory.CreateParameterSymbol(parameterSymbol, "v") }, methodKind: MethodKind.Conversion)); }
private static async Task <ISymbol?> TryRehydrateAsync( Document document, CompletionItem item, CancellationToken cancellationToken ) { // If we're need to rehydrate the conversion, pull out the necessary parts. if (item.Properties.ContainsKey(RehydrateName)) { var symbols = await SymbolCompletionItem .GetSymbolsAsync(item, document, cancellationToken) .ConfigureAwait(false); if ( symbols.Length == 3 && symbols[0] is INamedTypeSymbol containingType && symbols[1] is ITypeSymbol fromType && symbols[2] is ITypeSymbol toType ) { return(CodeGenerationSymbolFactory.CreateConversionSymbol( toType: toType, fromType: CodeGenerationSymbolFactory.CreateParameterSymbol( fromType, "value" ), containingType: containingType, documentationCommentXml: item.Properties[DocumentationCommentXmlName] )); } return(null); } else { // Otherwise, just go retrieve the conversion directly. var symbols = await SymbolCompletionItem .GetSymbolsAsync(item, document, cancellationToken) .ConfigureAwait(false); return(symbols.Length == 1 ? symbols.Single() : null); } }
private IPropertySymbol GenerateProperty( IPropertySymbol property, DeclarationModifiers modifiers, Accessibility accessibility, ImplementTypePropertyGenerationBehavior propertyGenerationBehavior, CancellationToken cancellationToken) { if (property.GetMethod == null) { // Can't generate an auto-prop for a setter-only property. propertyGenerationBehavior = ImplementTypePropertyGenerationBehavior.PreferThrowingProperties; } var syntaxFactory = _document.GetLanguageService <SyntaxGenerator>(); var accessorBody = propertyGenerationBehavior == ImplementTypePropertyGenerationBehavior.PreferAutoProperties ? default : syntaxFactory.CreateThrowNotImplementedStatementBlock(_model.Compilation); var getMethod = ShouldGenerateAccessor(property.GetMethod) ? CodeGenerationSymbolFactory.CreateAccessorSymbol( property.GetMethod, attributes: default, accessibility: property.GetMethod.ComputeResultantAccessibility(_state.ClassType), statements: accessorBody) : null; var setMethod = ShouldGenerateAccessor(property.SetMethod) ? CodeGenerationSymbolFactory.CreateAccessorSymbol( property.SetMethod, attributes: default, accessibility: property.SetMethod.ComputeResultantAccessibility(_state.ClassType), statements: accessorBody) : null; return(CodeGenerationSymbolFactory.CreatePropertySymbol( property, accessibility: accessibility, modifiers: modifiers, getMethod: getMethod, setMethod: setMethod)); }
internal static IMethodSymbol GenerateSetPropertyMethod(Compilation compilation) { var body = SyntaxFactory.ParseStatement( @"if (!System.Collections.Generic.EqualityComparer<T>.Default.Equals(field, value)) { field = value; var handler = PropertyChanged; if (handler != null) { handler(this, new System.ComponentModel.PropertyChangedEventArgs(name)); } }"); body = body.WithAdditionalAnnotations(Simplifier.Annotation); var stringType = compilation.GetSpecialType(SpecialType.System_String); var voidType = compilation.GetSpecialType(SpecialType.System_Void); var typeParameter = CodeGenerationSymbolFactory.CreateTypeParameterSymbol("T"); var parameter1 = CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: null, refKind: RefKind.Ref, isParams: false, type: typeParameter, name: "field"); var parameter2 = CodeGenerationSymbolFactory.CreateParameterSymbol(typeParameter, "value"); var parameter3 = CodeGenerationSymbolFactory.CreateParameterSymbol(stringType, "name"); return(CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: null, accessibility: Microsoft.CodeAnalysis.Accessibility.Private, modifiers: new SymbolModifiers(), returnType: voidType, explicitInterfaceSymbol: null, name: "SetProperty", typeParameters: new[] { typeParameter }, parameters: new[] { parameter1, parameter2, parameter3 }, statements: new[] { body })); }
private static SyntaxNode GetNewMethodDeclaration( IMethodSymbol method, TArgumentSyntax argument, SeparatedSyntaxList <TArgumentSyntax> argumentList, SyntaxGenerator generator, SyntaxNode declaration, ISemanticFactsService semanticFacts, string argumentName, SyntaxNode expression, SemanticModel semanticModel, ITypeSymbol parameterType) { if (!string.IsNullOrWhiteSpace(argumentName)) { var newParameterSymbol = CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: default(ImmutableArray <AttributeData>), refKind: RefKind.None, isParams: false, type: parameterType, name: argumentName); var newParameterDeclaration = generator.ParameterDeclaration(newParameterSymbol); return(generator.AddParameters(declaration, new[] { newParameterDeclaration })); } else { var name = semanticFacts.GenerateNameForExpression(semanticModel, expression); var uniqueName = NameGenerator.EnsureUniqueness(name, method.Parameters.Select(p => p.Name)); var newParameterSymbol = CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: default(ImmutableArray <AttributeData>), refKind: RefKind.None, isParams: false, type: parameterType, name: uniqueName); var argumentIndex = argumentList.IndexOf(argument); var newParameterDeclaration = generator.ParameterDeclaration(newParameterSymbol); return(generator.InsertParameters( declaration, argumentIndex, new[] { newParameterDeclaration })); } }
internal IPropertySymbol GenerateProperty( SyntaxGenerator factory, bool isAbstract, bool includeSetter, CancellationToken cancellationToken) { var accessibility = DetermineAccessibility(isAbstract); var getMethod = CodeGenerationSymbolFactory.CreateAccessorSymbol( attributes: default(ImmutableArray <AttributeData>), accessibility: accessibility, statements: GenerateStatements(factory, isAbstract, cancellationToken)); var setMethod = includeSetter ? getMethod : null; return(CodeGenerationSymbolFactory.CreatePropertySymbol( attributes: default(ImmutableArray <AttributeData>), accessibility: accessibility, modifiers: new DeclarationModifiers(isStatic: State.IsStatic, isAbstract: isAbstract), type: DetermineReturnType(cancellationToken), returnsByRef: DetermineReturnsByRef(cancellationToken), explicitInterfaceImplementations: default,
private IEnumerable <CodeAction> CreateCodeActions(Document document, State state) { var lastParameter = state.DelegatedConstructor.Parameters.Last(); if (!lastParameter.IsOptional) { yield return(new AddConstructorParametersCodeAction(this, document, state, state.Parameters)); } var parameters = state.Parameters.Select(p => CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: null, refKind: p.RefKind, isParams: p.IsParams, type: p.Type, name: p.Name, isOptional: true, hasDefaultValue: true)).ToList(); yield return(new AddConstructorParametersCodeAction(this, document, state, parameters)); }
protected IList <IParameterSymbol> CreateMethodParameters() { var parameters = new List <IParameterSymbol>(); foreach (var parameter in this.AnalyzerResult.MethodParameters) { var refKind = GetRefKind(parameter.ParameterModifier); var type = parameter.GetVariableType(this.SemanticDocument); parameters.Add( CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: SpecializedCollections.EmptyList <AttributeData>(), refKind: refKind, isParams: false, type: type, name: parameter.Name)); } return(parameters); }
private void AddExceptionConstructors(ArrayBuilder <ISymbol> members) { var factory = _document.Project.LanguageServices.GetService <SyntaxGenerator>(); var exceptionType = _document.SemanticModel.Compilation.ExceptionType(); var constructors = exceptionType.InstanceConstructors .Where(c => c.DeclaredAccessibility == Accessibility.Public || c.DeclaredAccessibility == Accessibility.Protected) .Select(c => CodeGenerationSymbolFactory.CreateConstructorSymbol( attributes: default(ImmutableArray <AttributeData>), accessibility: c.DeclaredAccessibility, modifiers: default(DeclarationModifiers), typeName: DetermineName(), parameters: c.Parameters, statements: default(ImmutableArray <SyntaxNode>), baseConstructorArguments: c.Parameters.Length == 0 ? default(ImmutableArray <SyntaxNode>) : factory.CreateArguments(c.Parameters))); members.AddRange(constructors); }
protected ImmutableArray <IParameterSymbol> CreateMethodParameters() { var parameters = ArrayBuilder <IParameterSymbol> .GetInstance(); foreach (var parameter in AnalyzerResult.MethodParameters) { var refKind = GetRefKind(parameter.ParameterModifier); var type = parameter.GetVariableType(SemanticDocument); parameters.Add( CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: ImmutableArray <AttributeData> .Empty, refKind: refKind, isParams: false, type: type, name: parameter.Name)); } return(parameters.ToImmutableAndFree()); }
protected override async Task <OperationStatus <IMethodSymbol> > GenerateMethodDefinitionAsync(CancellationToken cancellationToken) { var result = await CreateMethodBodyAsync(cancellationToken).ConfigureAwait(false); var methodSymbol = CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: ImmutableArray <AttributeData> .Empty, accessibility: Accessibility.Private, modifiers: CreateMethodModifiers(), returnType: this.AnalyzerResult.ReturnType, returnsByRef: false, explicitInterfaceSymbol: null, name: _methodName.ToString(), typeParameters: CreateMethodTypeParameters(cancellationToken), parameters: CreateMethodParameters(), statements: result.Data); return(result.With( this.MethodDefinitionAnnotation.AddAnnotationToSymbol( Formatter.Annotation.AddAnnotationToSymbol(methodSymbol)))); }
public static IMethodSymbol CreateEqualsMethod( this ISyntaxFactoryService factory, Compilation compilation, INamedTypeSymbol containingType, IList <ISymbol> symbols, CancellationToken cancellationToken) { var statements = CreateEqualsMethodStatements(factory, compilation, containingType, symbols, cancellationToken); return(CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: null, accessibility: Accessibility.Public, modifiers: new SymbolModifiers(isOverride: true), returnType: compilation.GetSpecialType(SpecialType.System_Boolean), explicitInterfaceSymbol: null, name: EqualsName, typeParameters: null, parameters: new[] { CodeGenerationSymbolFactory.CreateParameterSymbol(compilation.GetSpecialType(SpecialType.System_Object), ObjName) }, statements: statements)); }
public static IMethodSymbol CreateGetHashCodeMethod( this SyntaxGenerator factory, Compilation compilation, INamedTypeSymbol containingType, IList <ISymbol> symbols, CancellationToken cancellationToken) { var statements = CreateGetHashCodeMethodStatements(factory, compilation, containingType, symbols, cancellationToken); return(CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: null, accessibility: Accessibility.Public, modifiers: new DeclarationModifiers(isOverride: true), returnType: compilation.GetSpecialType(SpecialType.System_Int32), explicitInterfaceSymbol: null, name: GetHashCodeName, typeParameters: null, parameters: null, statements: statements)); }
internal async override Task <Document> GetUpdatedDocumentAsync(Document document, SemanticModel model, SyntaxNode root, SyntaxNode nodeToFix, string diagnosticId, CancellationToken cancellationToken) { var syntaxFactoryService = document.GetLanguageService <SyntaxGenerator>(); var symbol = model.GetDeclaredSymbol(nodeToFix); // There was no constructor and so the diagnostic was on the type. Generate a serlialization ctor. if (symbol.Kind == SymbolKind.NamedType) { var typeSymbol = symbol as INamedTypeSymbol; var throwStatement = syntaxFactoryService.CreateThrowNotImplementedStatementBlock(model.Compilation); var parameters = ImmutableArray.Create( CodeGenerationSymbolFactory.CreateParameterSymbol(WellKnownTypes.SerializationInfo(model.Compilation), "serializationInfo"), CodeGenerationSymbolFactory.CreateParameterSymbol(WellKnownTypes.StreamingContext(model.Compilation), "streamingContext")); var ctorSymbol = CodeGenerationSymbolFactory.CreateConstructorSymbol(null, typeSymbol.IsSealed ? Accessibility.Private : Accessibility.Protected, new SymbolModifiers(), typeSymbol.Name, parameters, throwStatement); return(await CodeGenerator.AddMethodDeclarationAsync(document.Project.Solution, typeSymbol, ctorSymbol).ConfigureAwait(false)); } else if (symbol.Kind == SymbolKind.Method) { // There is a serialization constructor but with incorrect accessibility. Set that right. var methodSymbol = symbol as IMethodSymbol; // This would be constructor and can have only one definition. Debug.Assert(methodSymbol.IsConstructor() && methodSymbol.DeclaringSyntaxReferences.Count() == 1); var declaration = await methodSymbol.DeclaringSyntaxReferences.First().GetSyntaxAsync(cancellationToken); var newAccessibility = methodSymbol.ContainingType.IsSealed ? Accessibility.Private : Accessibility.Protected; var newDecl = CodeGenerator.UpdateDeclarationAccessibility(declaration, document.Project.Solution.Workspace, newAccessibility, cancellationToken: cancellationToken); return(document.WithSyntaxRoot(root.ReplaceNode(declaration, newDecl))); } return(document); }
public static async Task <IMethodSymbol> OverrideMethodAsync( this SyntaxGenerator codeFactory, IMethodSymbol overriddenMethod, DeclarationModifiers modifiers, INamedTypeSymbol newContainingType, Document newDocument, CancellationToken cancellationToken) { // Abstract: Throw not implemented if (overriddenMethod.IsAbstract) { var compilation = await newDocument.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); var statement = codeFactory.CreateThrowNotImplementedStatement(compilation); return(CodeGenerationSymbolFactory.CreateMethodSymbol( overriddenMethod, accessibility: overriddenMethod.ComputeResultantAccessibility(newContainingType), modifiers: modifiers, statements: ImmutableArray.Create(statement))); } else { // Otherwise, call the base method with the same parameters var typeParams = overriddenMethod.GetTypeArguments(); var body = codeFactory.InvocationExpression( codeFactory.MemberAccessExpression(codeFactory.BaseExpression(), typeParams.IsDefaultOrEmpty ? codeFactory.IdentifierName(overriddenMethod.Name) : codeFactory.GenericName(overriddenMethod.Name, typeParams)), codeFactory.CreateArguments(overriddenMethod.GetParameters())); return(CodeGenerationSymbolFactory.CreateMethodSymbol( method: overriddenMethod, accessibility: overriddenMethod.ComputeResultantAccessibility(newContainingType), modifiers: modifiers, statements: overriddenMethod.ReturnsVoid ? ImmutableArray.Create(codeFactory.ExpressionStatement(body)) : ImmutableArray.Create(codeFactory.ReturnStatement(body)))); } }
private IMethodSymbol GetMethodSymbol( SemanticDocument document, string eventHandlerMethodName, AssignmentExpressionSyntax eventHookupExpression, CancellationToken cancellationToken) { var semanticModel = document.SemanticModel as SemanticModel; var symbolInfo = semanticModel.GetSymbolInfo(eventHookupExpression.Left, cancellationToken); var symbol = symbolInfo.Symbol; if (symbol == null || symbol.Kind != SymbolKind.Event) { return(null); } var typeInference = document.Project.LanguageServices.GetService <ITypeInferenceService>(); var delegateType = typeInference.InferDelegateType(semanticModel, eventHookupExpression.Right, cancellationToken); if (delegateType == null || delegateType.DelegateInvokeMethod == null) { return(null); } var syntaxFactory = document.Project.LanguageServices.GetService <SyntaxGenerator>(); return(CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: null, accessibility: Accessibility.Private, modifiers: new DeclarationModifiers(isStatic: eventHookupExpression.IsInStaticContext()), returnType: delegateType.DelegateInvokeMethod.ReturnType, returnsByRef: delegateType.DelegateInvokeMethod.ReturnsByRef, explicitInterfaceSymbol: null, name: eventHandlerMethodName, typeParameters: null, parameters: delegateType.DelegateInvokeMethod.Parameters, statements: new List <SyntaxNode> { CodeGenerationHelpers.GenerateThrowStatement(syntaxFactory, document, "System.NotImplementedException", cancellationToken) })); }
private IPropertySymbol CreateProperty( IParameterSymbol parameter, ImmutableArray <NamingRule> rules, List <string> parameterNameParts) { foreach (var rule in rules) { if (rule.SymbolSpecification.AppliesTo(SymbolKind.Property, Accessibility.Public)) { var uniqueName = GenerateUniqueName(parameter, parameterNameParts, rule); var getMethod = CodeGenerationSymbolFactory.CreateAccessorSymbol( default(ImmutableArray <AttributeData>), Accessibility.Public, default(ImmutableArray <SyntaxNode>)); return(CodeGenerationSymbolFactory.CreatePropertySymbol( default(ImmutableArray <AttributeData>), Accessibility.Public, new DeclarationModifiers(), parameter.Type, returnsByRef: false, explicitInterfaceImplementations: default,
protected ImmutableArray <IParameterSymbol> DetermineParameters( ImmutableArray <ISymbol> selectedMembers) { var parameters = ArrayBuilder <IParameterSymbol> .GetInstance(); foreach (var symbol in selectedMembers) { var type = symbol is IFieldSymbol ? ((IFieldSymbol)symbol).Type : ((IPropertySymbol)symbol).Type; parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: default(ImmutableArray <AttributeData>), refKind: RefKind.None, isParams: false, type: type, name: symbol.Name.ToCamelCase().TrimStart(s_underscore))); } return(parameters.ToImmutableAndFree()); }
protected List <IParameterSymbol> DetermineParameters( IList <ISymbol> selectedMembers) { var parameters = new List <IParameterSymbol>(); foreach (var symbol in selectedMembers) { var type = symbol is IFieldSymbol ? ((IFieldSymbol)symbol).Type : ((IPropertySymbol)symbol).Type; parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: null, refKind: RefKind.None, isParams: false, type: type, name: symbol.Name.ToCamelCase())); } return(parameters); }
private static IMethodSymbol GenerateMethodSymbol( INamedTypeSymbol typeToGenerateIn, INamedTypeSymbol parameterSymbol) { // Remove any generic parameters if (typeToGenerateIn.IsGenericType) { typeToGenerateIn = typeToGenerateIn.ConstructUnboundGenericType().ConstructedFrom; } return(CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: ImmutableArray <AttributeData> .Empty, accessibility: default(Accessibility), modifiers: default(DeclarationModifiers), returnType: typeToGenerateIn, returnsByRef: false, explicitInterfaceSymbol: null, name: null, typeParameters: ImmutableArray <ITypeParameterSymbol> .Empty, parameters: ImmutableArray.Create(CodeGenerationSymbolFactory.CreateParameterSymbol(parameterSymbol, "v")), methodKind: MethodKind.Conversion)); }
private IFieldSymbol CreateField( IParameterSymbol parameter, ImmutableArray <NamingRule> rules, List <string> parameterNameParts) { foreach (var rule in rules) { if (rule.SymbolSpecification.AppliesTo(SymbolKind.Field, Accessibility.Private)) { var uniqueName = GenerateUniqueName(parameter, parameterNameParts, rule); return(CodeGenerationSymbolFactory.CreateFieldSymbol( default(ImmutableArray <AttributeData>), Accessibility.Private, DeclarationModifiers.ReadOnly, parameter.Type, uniqueName)); } } // We place a special rule in s_builtInRules that matches all fields. So we should // always find a matching rule. throw ExceptionUtilities.Unreachable; }
internal static async Task TestAddNamespaceAsync( string initial, string expected, string name = "N", IList <ISymbol> imports = null, IList <INamespaceOrTypeSymbol> members = null, CodeGenerationContext context = null) { using var testContext = await TestContext.CreateAsync(initial, expected); var @namespace = CodeGenerationSymbolFactory.CreateNamespaceSymbol(name, imports, members); testContext.Result = await testContext.Service.AddNamespaceAsync( new CodeGenerationSolutionContext( testContext.Solution, context ?? CodeGenerationContext.Default, testContext.Workspace.GlobalOptions.CreateProvider()), (INamespaceSymbol)testContext.GetDestination(), @namespace, CancellationToken.None); }
internal static async Task TestAddMethodAsync( string initial, string expected, string name = "M", Accessibility accessibility = Accessibility.Public, Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers), Type returnType = null, Func <SemanticModel, ImmutableArray <IMethodSymbol> > getExplicitInterfaces = null, ImmutableArray <ITypeParameterSymbol> typeParameters = default(ImmutableArray <ITypeParameterSymbol>), ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >), string statements = null, ImmutableArray <SyntaxNode> handlesExpressions = default(ImmutableArray <SyntaxNode>), CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions), bool ignoreTrivia = true) { if (statements != null) { expected = expected.Replace("$$", statements); } using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia)) { var parameterSymbols = GetParameterSymbols(parameters, context); var parsedStatements = context.ParseStatements(statements); var explicitInterfaceImplementations = GetMethodSymbols(getExplicitInterfaces, context); var method = CodeGenerationSymbolFactory.CreateMethodSymbol( default(ImmutableArray <AttributeData>), accessibility, modifiers, GetTypeSymbol(returnType)(context.SemanticModel), false, explicitInterfaceImplementations, name, typeParameters, parameterSymbols, parsedStatements, handlesExpressions: handlesExpressions); context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions); } }
internal static async Task TestAddUnsupportedOperatorAsync( string initial, CodeGenerationOperatorKind operatorKind, Accessibility accessibility = Accessibility.Public, DeclarationModifiers modifiers = default(DeclarationModifiers), Type returnType = null, IList <Func <SemanticModel, IParameterSymbol> > parameters = null, string statements = null, CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions), bool compareTokens = true) { using (var context = await TestContext.CreateAsync(initial, initial, ignoreResult: true)) { var parameterSymbols = GetParameterSymbols(parameters, context); var parsedStatements = context.ParseStatements(statements); var method = CodeGenerationSymbolFactory.CreateOperatorSymbol( null, accessibility, modifiers, GetTypeSymbol(returnType)(context.SemanticModel), operatorKind, parameterSymbols, parsedStatements); ArgumentException exception = null; try { await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions); } catch (ArgumentException e) { exception = e; } var expectedMessage = string.Format(WorkspacesResources.CannotCodeGenUnsupportedOperator, method.Name); Assert.True(exception != null && exception.Message.StartsWith(expectedMessage, StringComparison.Ordinal), string.Format("\r\nExpected exception: {0}\r\nActual exception: {1}\r\n", expectedMessage, exception == null ? "no exception" : exception.Message)); } }
private ISymbol GenerateProperty( Compilation compilation, IPropertySymbol property, Accessibility accessibility, DeclarationModifiers modifiers, bool generateAbstractly, bool useExplicitInterfaceSymbol, string memberName, ImplementTypePropertyGenerationBehavior propertyGenerationBehavior, CancellationToken cancellationToken) { var factory = this.Document.GetLanguageService <SyntaxGenerator>(); var attributesToRemove = AttributesToRemove(compilation); var getAccessor = GenerateGetAccessor( compilation, property, accessibility, generateAbstractly, useExplicitInterfaceSymbol, propertyGenerationBehavior, attributesToRemove, cancellationToken); var setAccessor = GenerateSetAccessor( compilation, property, accessibility, generateAbstractly, useExplicitInterfaceSymbol, propertyGenerationBehavior, attributesToRemove, cancellationToken); var syntaxFacts = Document.GetLanguageService <ISyntaxFactsService>(); var parameterNames = NameGenerator.EnsureUniqueness( property.Parameters.Select(p => p.Name).ToList(), isCaseSensitive: syntaxFacts.IsCaseSensitive); var updatedProperty = property.RenameParameters(parameterNames); updatedProperty = updatedProperty.RemoveAttributeFromParameters(attributesToRemove); // TODO(cyrusn): Delegate through throughMember if it's non-null. return(CodeGenerationSymbolFactory.CreatePropertySymbol( updatedProperty, accessibility: accessibility, modifiers: modifiers, explicitInterfaceSymbol: useExplicitInterfaceSymbol ? property : null, name: memberName, getMethod: getAccessor, setMethod: setAccessor)); }
protected ImmutableArray <ITypeParameterSymbol> CreateMethodTypeParameters() { if (AnalyzerResult.MethodTypeParametersInDeclaration.Count == 0) { return(ImmutableArray <ITypeParameterSymbol> .Empty); } var set = new HashSet <ITypeParameterSymbol>( AnalyzerResult.MethodTypeParametersInConstraintList ); var typeParameters = ArrayBuilder <ITypeParameterSymbol> .GetInstance(); foreach (var parameter in AnalyzerResult.MethodTypeParametersInDeclaration) { if (parameter != null && set.Contains(parameter)) { typeParameters.Add(parameter); continue; } typeParameters.Add( CodeGenerationSymbolFactory.CreateTypeParameter( parameter.GetAttributes(), parameter.Variance, parameter.Name, ImmutableArray.Create <ITypeSymbol>(), parameter.NullableAnnotation, parameter.HasConstructorConstraint, parameter.HasReferenceTypeConstraint, parameter.HasUnmanagedTypeConstraint, parameter.HasValueTypeConstraint, parameter.HasNotNullConstraint, parameter.Ordinal ) ); } return(typeParameters.ToImmutableAndFree()); }
internal static async Task TestAddMethodAsync( string initial, string expected, string name = "M", Accessibility accessibility = Accessibility.Public, DeclarationModifiers modifiers = default(DeclarationModifiers), Type returnType = null, Func <SemanticModel, IMethodSymbol> explicitInterface = null, IList <ITypeParameterSymbol> typeParameters = null, IList <Func <SemanticModel, IParameterSymbol> > parameters = null, string statements = null, IList <SyntaxNode> handlesExpressions = null, CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions), bool compareTokens = true) { if (statements != null) { expected = expected.Replace("$$", statements); } using (var context = await TestContext.CreateAsync(initial, expected, compareTokens)) { var parameterSymbols = GetParameterSymbols(parameters, context); var parsedStatements = context.ParseStatements(statements); var explicitInterfaceSymbol = GetMethodSymbol(explicitInterface, context); var method = CodeGenerationSymbolFactory.CreateMethodSymbol( null, accessibility, modifiers, GetTypeSymbol(returnType)(context.SemanticModel), false, explicitInterfaceSymbol, name, typeParameters, parameterSymbols, parsedStatements, handlesExpressions: handlesExpressions); context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions); } }
private void GetParameters( ImmutableArray <TArgumentSyntax> arguments, ImmutableArray <TAttributeArgumentSyntax>?attributeArguments, ImmutableArray <ITypeSymbol> parameterTypes, ImmutableArray <ParameterName> parameterNames, out Dictionary <string, ISymbol> parameterToExistingFieldMap, out Dictionary <string, string> parameterToNewFieldMap, out ImmutableArray <IParameterSymbol> parameters) { parameterToExistingFieldMap = new Dictionary <string, ISymbol>(); parameterToNewFieldMap = new Dictionary <string, string>(); var result = ArrayBuilder <IParameterSymbol> .GetInstance(); for (var i = 0; i < parameterNames.Length; i++) { // See if there's a matching field we can use. First test in a case sensitive // manner, then case insensitively. if (!TryFindMatchingField( arguments, attributeArguments, parameterNames, parameterTypes, i, parameterToExistingFieldMap, parameterToNewFieldMap, caseSensitive: true, newParameterNames: out parameterNames)) { if (!TryFindMatchingField(arguments, attributeArguments, parameterNames, parameterTypes, i, parameterToExistingFieldMap, parameterToNewFieldMap, caseSensitive: false, newParameterNames: out parameterNames)) { parameterToNewFieldMap[parameterNames[i].BestNameForParameter] = parameterNames[i].NameBasedOnArgument; } } result.Add(CodeGenerationSymbolFactory.CreateParameterSymbol( attributes: default(ImmutableArray <AttributeData>), refKind: _service.GetRefKind(arguments[i]), isParams: false, type: parameterTypes[i], name: parameterNames[i].BestNameForParameter)); } parameters = result.ToImmutableAndFree(); }