private static bool ShouldUseOverrideKeyword(MemberDeclarationSyntax member, bool isInterface) { ISymbol symbol = TypeProcessor.GetDeclaredSymbol(member); if (symbol is IMethodSymbol) { if ((symbol as IMethodSymbol).IsGenericMethod) return false; } if (symbol.ContainingType.TypeKind == TypeKind.Struct || symbol.ContainingType.TypeKind == TypeKind.Interface) { return false; // Structs dont have a base class to override (maybe opEquals) ... but that will be handled separately //Interfaces are contracts, so no overriding here// maybe we should compare the methods } if (member.GetModifiers().Any(SyntaxKind.OverrideKeyword) && !isInterface) return true; if (member.GetModifiers().Any(SyntaxKind.StaticKeyword)) return false; // if (method.Modifiers.Any(SyntaxKind.NewKeyword)) // return symbol.ContainingType.BaseType.GetMembers(symbol.Name).Any(k=>k.IsAbstract || k.IsVirtual); if (member.GetModifiers().Any(SyntaxKind.PartialKeyword)) //partial methods seem exempt from C#'s normal override keyword requirement, so we have to check manually to see if it exists in a base class return symbol.ContainingType.BaseType.GetMembers(symbol.Name).Any(); return member.GetModifiers().Any(SyntaxKind.OverrideKeyword); }
public static ClassDeclarationSyntax Create(string name, BaseTypeSyntax[] baseTypes, ConstructorDeclarationSyntax constructor, MemberDeclarationSyntax[] body) { return SyntaxFactory.ClassDeclaration(name) .AddBaseListTypes(baseTypes) .AddMembers(constructor) .AddMembers(body); }
private Accessibility GetDeclaredAccessibility(MemberDeclarationSyntax declaration) { var result = Accessibility.Private; SyntaxTokenList? syntaxTokenList; syntaxTokenList = (declaration as PropertyDeclarationSyntax)?.Modifiers ?? (declaration as FieldDeclarationSyntax)?.Modifiers ?? (declaration as ConstructorDeclarationSyntax)?.Modifiers ?? (declaration as MethodDeclarationSyntax)?.Modifiers; var accessibilityToken = syntaxTokenList?.Where(x => accessibilityTypes.Contains(x.Kind())).FirstOrDefault(); if (accessibilityToken.HasValue) { switch (accessibilityToken.Value.Kind()) { case SyntaxKind.PublicKeyword: result = Accessibility.Public; break; case SyntaxKind.PrivateKeyword: result = Accessibility.Private; break; case SyntaxKind.InternalKeyword: result = Accessibility.Internal; break; case SyntaxKind.ProtectedKeyword: result = Accessibility.Protected; break; default: result = Accessibility.Private; break; } } return result; }
/// <inheritdoc /> public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, Document document, IProgress<Diagnostic> progress, CancellationToken cancellationToken) { 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 intPtrOverload = method .WithParameterList(TransformParameterList(method.ParameterList)) .WithReturnType(TransformReturnType(method.ReturnType)) .WithIdentifier(TransformMethodName(method)) .WithModifiers(RemoveModifier(method.Modifiers, SyntaxKind.ExternKeyword)) .WithAttributeLists(SyntaxFactory.List<AttributeListSyntax>()) .WithLeadingTrivia(method.GetLeadingTrivia().Where(t => !t.IsDirective)) .WithTrailingTrivia(method.GetTrailingTrivia().Where(t => !t.IsDirective)) .WithBody(CallNativePointerOverload(method)) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)); generatedType = generatedType.AddMembers(intPtrOverload); } return Task.FromResult(SyntaxFactory.SingletonList<MemberDeclarationSyntax>(generatedType)); }
private static void CheckDeclarationName(MemberDeclarationSyntax member, SyntaxToken identifier, SyntaxNodeAnalysisContext context) { var symbol = context.SemanticModel.GetDeclaredSymbol(member); if (ClassName.IsTypeComRelated(symbol?.ContainingType) || symbol.IsInterfaceImplementationOrMemberOverride() || symbol.IsExtern) { return; } if (identifier.ValueText.StartsWith("_", StringComparison.Ordinal) || identifier.ValueText.EndsWith("_", StringComparison.Ordinal)) { context.ReportDiagnostic(Diagnostic.Create(Rule, identifier.GetLocation(), MethodKindNameMapping[member.Kind()], identifier.ValueText, MessageFormatUnderscore)); return; } string suggestion; if (TryGetChangedName(identifier.ValueText, out suggestion)) { var messageEnding = string.Format(MessageFormatNonUnderscore, suggestion); context.ReportDiagnostic(Diagnostic.Create(Rule, identifier.GetLocation(), MethodKindNameMapping[member.Kind()], identifier.ValueText, messageEnding)); } }
public YieldClassGenerator(Compilation compilation, ClassDeclarationSyntax classDeclarationSyntax, MemberDeclarationSyntax node) { this.compilation = compilation; this.classDeclarationSyntax = classDeclarationSyntax; this.node = node; method = ModelExtensions.GetDeclaredSymbol(compilation.GetSemanticModel(node.SyntaxTree), node); }
/// <summary> /// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct. /// </summary> /// <param name="member">The member to wrap.</param> public MemberOrderHelper(MemberDeclarationSyntax member) { this.Member = member; var modifiers = member.GetModifiers(); this.modifierFlags = GetModifierFlags(modifiers); this.accessibilty = AccessLevelHelper.GetAccessLevel(modifiers); }
public static bool HasYield(MemberDeclarationSyntax method) { if (method.IsAsync()) return false; var yieldChecker = new YieldChecker(true); method.Accept(yieldChecker); return yieldChecker.isSpecial; }
private SyntaxNode VisitMemberDeclaration(MemberDeclarationSyntax node, SyntaxNode newNode) { var newMember = ((MemberDeclarationSyntax) newNode).WithoutAttributes(); var isSolutionPart = node.HasAttribute<ExcludeFromSolutionAttribute>() || node.HasAttribute<ExerciseAttribute>(); if (node.HasAttribute<ExcludeFromSolutionAttribute>() || (node is TypeDeclarationSyntax && node.HasAttribute<ExerciseAttribute>())) Exercise.EthalonSolution += newMember.ToFullString(); return isSolutionPart ? null : newMember; }
internal static int Sort(MemberDeclarationSyntax first, MemberDeclarationSyntax second) { Requires.NotNull(first, "first"); Requires.NotNull(second, "second"); int firstOrder = GetMemberDeclarationTypeOrder(first); int secondOrder = GetMemberDeclarationTypeOrder(second); int compareResult = firstOrder.CompareTo(secondOrder); if (compareResult == 0) { firstOrder = GetMemberDeclarationVisibilityOrder(first); secondOrder = GetMemberDeclarationVisibilityOrder(second); compareResult = firstOrder.CompareTo(secondOrder); if (compareResult == 0) { bool firstIsStatic = first.HasModifier(SyntaxKind.StaticKeyword); bool secondIsStatic = second.HasModifier(SyntaxKind.StaticKeyword); if (firstIsStatic && !secondIsStatic) { compareResult = -1; } else if (!firstIsStatic && secondIsStatic) { compareResult = 1; } if (compareResult == 0) { bool firstIsReadOnly = first.HasModifier(SyntaxKind.ReadOnlyKeyword); bool secondIsReadOnly = second.HasModifier(SyntaxKind.ReadOnlyKeyword); if (firstIsReadOnly && !secondIsReadOnly) { compareResult = -1; } else if (!firstIsReadOnly && secondIsReadOnly) { compareResult = 1; } if (compareResult == 0) { var firstName = GetName(first); var secondName = GetName(second); if (firstName.HasValue && secondName.HasValue) { compareResult = string.Compare(firstName.Value.ValueText, secondName.Value.ValueText, StringComparison.CurrentCulture); } } } } } return compareResult; }
/// <summary> /// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct. /// </summary> /// <param name="member">The member to wrap.</param> /// <param name="elementOrder">The element ordering traits.</param> internal MemberOrderHelper(MemberDeclarationSyntax member, ImmutableArray<OrderingTrait> elementOrder) { this.Member = member; var modifiers = member.GetModifiers(); var type = member.Kind(); type = type == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : type; this.Priority = 0; foreach (OrderingTrait trait in elementOrder) { switch (trait) { case OrderingTrait.Kind: // 4 bits are required to store this. this.Priority <<= 4; this.Priority |= TypeMemberOrder.IndexOf(type) & 0x0F; break; case OrderingTrait.Accessibility: // 3 bits are required to store this. this.Priority <<= 3; this.Priority |= (int)GetAccessLevelForOrdering(member, modifiers) & 0x07; break; case OrderingTrait.Constant: this.Priority <<= 1; if (modifiers.Any(SyntaxKind.ConstKeyword)) { this.Priority |= 1; } break; case OrderingTrait.Static: this.Priority <<= 1; if (modifiers.Any(SyntaxKind.StaticKeyword)) { this.Priority |= 1; } break; case OrderingTrait.Readonly: this.Priority <<= 1; if (modifiers.Any(SyntaxKind.ReadOnlyKeyword)) { this.Priority |= 1; } break; default: continue; } } }
private SyntaxNode VisitMemberDeclaration(MemberDeclarationSyntax node, SyntaxNode newNode) { var parent = node.GetParents().OfType<BaseTypeDeclarationSyntax>().FirstOrDefault(); if (!ShowOnSlide(node)) return null; if (parent == null || parent.HasAttribute<SlideAttribute>() || parent.HasAttribute<ShowBodyOnSlideAttribute>()) AddCodeBlock(((MemberDeclarationSyntax)newNode)); return ((MemberDeclarationSyntax)newNode).WithoutAttributes(); }
internal static IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticModel, MemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken) { if (memberDeclaration is FieldDeclarationSyntax) { return ((FieldDeclarationSyntax)memberDeclaration).Declaration.Variables.Select( v => semanticModel.GetDeclaredSymbol(v, cancellationToken)); } return SpecializedCollections.SingletonEnumerable( semanticModel.GetDeclaredSymbol(memberDeclaration, cancellationToken)); }
public static MemberDeclarationSyntax UpdateNamedTypeDeclaration( ICodeGenerationService service, MemberDeclarationSyntax declaration, IList<ISymbol> newMembers, CodeGenerationOptions options, CancellationToken cancellationToken) { declaration = RemoveAllMembers(declaration); declaration = service.AddMembers(declaration, newMembers, options, cancellationToken); return AddCleanupAnnotationsTo(declaration); }
protected SyntaxNode HoistVariable(CSharpSyntaxNode node, SyntaxToken identifier, TypeSyntax type) { if (hoistedVariables.ContainsKey(identifier.ToString())) { var newName = GenerateNewName(identifier); var newIdentifier = SyntaxFactory.Identifier(newName); node = IdentifierRenamer.RenameIdentifier(node, identifier, newIdentifier); identifier = newIdentifier; } hoistedVariables[identifier.ToString()] = type; return node; }
private async Task<Document> ExtractToExpressionTree(Document document, MemberDeclarationSyntax declaration, CancellationToken c) { var typeSyntax = declaration.Ancestors().OfType<TypeDeclarationSyntax>().First(); var sm = await document.GetSemanticModelAsync(c); var type = sm.GetDeclaredSymbol(typeSyntax, c); var symbol = sm.GetDeclaredSymbol(declaration); string name = declaration is MethodDeclarationSyntax ? ((MethodDeclarationSyntax)declaration).Identifier.ToString() : ((PropertyDeclarationSyntax)declaration).Identifier.ToString(); string candidateName = name + "Expression"; if (type.MemberNames.Contains(candidateName)) candidateName = Enumerable.Range(2, 1000).Select(i => name + "Expression" + i).First(n => !type.MemberNames.Contains(n)); List<ParameterSyntax> parameterList = GetParameters(declaration, type, symbol); TypeSyntax returnType = GetReturnType(declaration); var bodyExpression = GetSingleBody(declaration); var newField = GetStaticField(candidateName, parameterList, returnType, bodyExpression, sm, type); var newBody = GetNewBody(candidateName, parameterList); var newDeclaration = declaration.ReplaceNode(bodyExpression, newBody); MoveInitialTrivia(ref newField, ref newDeclaration); var newMembers = typeSyntax.Members.ReplaceRange(declaration, new[] { newField, newDeclaration }); var newType = typeSyntax is StructDeclarationSyntax ? (TypeDeclarationSyntax)((StructDeclarationSyntax)typeSyntax).WithMembers(newMembers) : (TypeDeclarationSyntax)((ClassDeclarationSyntax)typeSyntax).WithMembers(newMembers); var docRoot = await document.GetSyntaxRootAsync(); var newDoc = docRoot.ReplaceNode(typeSyntax, newType); var usings = newDoc.ChildNodes().OfType<UsingDirectiveSyntax>(); if (usings.Any() && !usings.Any(a => a.Name.ToString() == "System.Linq.Expressions")) newDoc = newDoc.InsertNodesAfter(usings.LastOrDefault(), new[] { SyntaxFactory.UsingDirective( SyntaxFactory.IdentifierName("System").Qualified("Linq").Qualified("Expressions") ).NormalizeWhitespace().WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed) }); return document.WithSyntaxRoot(newDoc); }
/// <inheritdoc /> public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, Document document, IProgress<Diagnostic> progress, CancellationToken cancellationToken) { var applyToStruct = applyTo as StructDeclarationSyntax; var applyToClass = applyTo as ClassDeclarationSyntax; var applyToType = applyTo as TypeDeclarationSyntax; var generatedMembers = SyntaxFactory.List<MemberDeclarationSyntax>(); var nativePointerFields = from field in applyToType.Members.OfType<FieldDeclarationSyntax>() where field.Declaration.Type is PointerTypeSyntax && field.Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword)) select field; foreach (var field in nativePointerFields) { foreach (var variable in field.Declaration.Variables) { generatedMembers = generatedMembers.Add( SyntaxFactory.PropertyDeclaration(IntPtrTypeSyntax, variable.Identifier.ValueText + "_IntPtr") .WithModifiers(field.Modifiers) //// get { return new IntPtr(this.field); } //// set { this.field = (byte*)value.ToPointer(); } .AddAccessorListAccessors( SyntaxFactory.AccessorDeclaration( SyntaxKind.GetAccessorDeclaration, SyntaxFactory.Block( SyntaxFactory.ReturnStatement( SyntaxFactory.ObjectCreationExpression(IntPtrTypeSyntax) .AddArgumentListArguments(SyntaxFactory.Argument(ThisDot(variable.Identifier)))))), SyntaxFactory.AccessorDeclaration( SyntaxKind.SetAccessorDeclaration, SyntaxFactory.Block( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, ThisDot(variable.Identifier), TypedAs( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("value"), SyntaxFactory.IdentifierName(nameof(IntPtr.ToPointer))), SyntaxFactory.ArgumentList()), field.Declaration.Type))))))); } } var generatedType = (TypeDeclarationSyntax)applyToStruct?.WithMembers(generatedMembers) .WithAttributeLists(SyntaxFactory.List<AttributeListSyntax>()) ?? applyToClass?.WithMembers(generatedMembers) .WithAttributeLists(SyntaxFactory.List<AttributeListSyntax>()); return Task.FromResult(SyntaxFactory.SingletonList<MemberDeclarationSyntax>(generatedType)); }
private static MemberDeclarationSyntax BeforeMember( SyntaxList<MemberDeclarationSyntax> members, MemberDeclarationSyntax eventDeclaration) { // If it's a field style event, then it goes before everything else if we don't have any // existing fields/events. if (eventDeclaration.Kind() == SyntaxKind.FieldDeclaration) { return members.FirstOrDefault(); } // Otherwise just place it before the methods. return FirstMethod(members); }
private static SyntaxNode MoveField(SyntaxNode root, MemberDeclarationSyntax field, MemberDeclarationSyntax firstNonConst) { var trackedRoot = root.TrackNodes(field, firstNonConst); var fieldToMove = trackedRoot.GetCurrentNode(field); var firstNonConstTracked = trackedRoot.GetCurrentNode(firstNonConst); if (!fieldToMove.HasLeadingTrivia) { fieldToMove = fieldToMove.WithLeadingTrivia(firstNonConstTracked.GetLeadingTrivia().Where(x => x.IsKind(SyntaxKind.WhitespaceTrivia)).LastOrDefault()); } root = trackedRoot.InsertNodesBefore(firstNonConstTracked, new[] { fieldToMove }); var fieldToMoveTracked = root.GetCurrentNodes(field).Last(); return root.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia); }
static bool IsObsolete (MemberDeclarationSyntax entity) { if (entity == null) return false; // TODO! // foreach (var section in entity.Attributes) { // foreach (var attr in section.Attributes) { // var attrText = attr.Type.ToString (); // if (attrText == "Obsolete" || attrText == "ObsoleteAttribute" || attrText == "System.Obsolete" || attrText == "System.ObsoleteAttribute" ) // return true; // } // } return false; }
public Task<IReadOnlyList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, Document document, IProgress<Diagnostic> progress, CancellationToken cancellationToken) { Requires.NotNull(applyTo, nameof(applyTo)); var options = new CodeGen.Options(this.attributeData) { GenerateBuilder = this.GetBoolData(nameof(GenerateImmutableAttribute.GenerateBuilder)), Delta = this.GetBoolData(nameof(GenerateImmutableAttribute.Delta)), DefineInterface = this.GetBoolData(nameof(GenerateImmutableAttribute.DefineInterface)), DefineRootedStruct = this.GetBoolData(nameof(GenerateImmutableAttribute.DefineRootedStruct)), DefineWithMethodsPerProperty = this.GetBoolData(nameof(GenerateImmutableAttribute.DefineWithMethodsPerProperty)), }; return CodeGen.GenerateAsync((ClassDeclarationSyntax)applyTo, document, progress, options, cancellationToken); }
private IEnumerable<SyntaxNode> GetAllTopLevelTypeDefined(MemberDeclarationSyntax member) { var namespaceMember = member as NamespaceDeclarationSyntax; if (namespaceMember != null) { return namespaceMember.Members.SelectMany(GetAllTopLevelTypeDefined); } var type = member as ClassDeclarationSyntax; if (type != null) { return SpecializedCollections.SingletonEnumerable<SyntaxNode>(type); } return SpecializedCollections.EmptyEnumerable<SyntaxNode>(); }
public static bool IsEvalCandidate(this SemanticModel model, MemberDeclarationSyntax member) { if (member.Kind() != SyntaxKind.FieldDeclaration) return false; var field = member as FieldDeclarationSyntax; var attrDeclares = field.AttributeLists; foreach (var attrDeclare in attrDeclares) { foreach (var attr in attrDeclare.Attributes) { var type = model.GetTypeInfo(attr); if (type.Type.IsSameType(nameof(JavaScript), nameof(EvalAtCompileAttribute))) return true; } } return false; }
/// <summary> /// The get member name. /// </summary> /// <param name="declarationNode"> /// The declaration node. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> /// <exception cref="ArgumentNullException"><paramref name="declarationNode"/> is <see langword="null" />.</exception> public string GetMemberName(MemberDeclarationSyntax declarationNode) { if (declarationNode == null) { throw new ArgumentNullException(nameof(declarationNode)); } FieldDeclarationSyntax fieldDeclaration = declarationNode as FieldDeclarationSyntax; if (fieldDeclaration != null) { return fieldDeclaration.Declaration.Variables[0].Identifier.ValueText; } PropertyDeclarationSyntax propertyDeclaration = declarationNode as PropertyDeclarationSyntax; if (propertyDeclaration != null) { return propertyDeclaration.Identifier.ValueText; } return null; }
/// <summary> /// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct. /// </summary> /// <param name="member">The member to wrap.</param> /// <param name="checks">The element ordering checks.</param> internal MemberOrderHelper(MemberDeclarationSyntax member, ElementOrderingChecks checks) { this.Member = member; var modifiers = member.GetModifiers(); var type = member.Kind(); type = type == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : type; this.elementPriority = checks.ElementType ? TypeMemberOrder.IndexOf(type) : 0; this.modifierFlags = GetModifierFlags(modifiers, checks); if (checks.AccessLevel) { if ((type == SyntaxKind.ConstructorDeclaration && this.modifierFlags.HasFlag(ModifierFlags.Static)) || (type == SyntaxKind.MethodDeclaration && ((MethodDeclarationSyntax)member).ExplicitInterfaceSpecifier != null) || (type == SyntaxKind.PropertyDeclaration && ((PropertyDeclarationSyntax)member).ExplicitInterfaceSpecifier != null) || (type == SyntaxKind.IndexerDeclaration && ((IndexerDeclarationSyntax)member).ExplicitInterfaceSpecifier != null)) { this.accessibilty = AccessLevel.Public; } else { this.accessibilty = AccessLevelHelper.GetAccessLevel(modifiers); if (this.accessibilty == AccessLevel.NotSpecified) { if (member.Parent.IsKind(SyntaxKind.CompilationUnit) || member.Parent.IsKind(SyntaxKind.NamespaceDeclaration)) { this.accessibilty = AccessLevel.Internal; } else { this.accessibilty = AccessLevel.Private; } } } } else { this.accessibilty = AccessLevel.Public; } }
private static MemberDeclarationSyntax AfterMember( SyntaxList<MemberDeclarationSyntax> members, MemberDeclarationSyntax eventDeclaration) { if (eventDeclaration.Kind() == SyntaxKind.EventFieldDeclaration) { // Field style events go after the last field event, or after the last field. var lastEvent = members.LastOrDefault(m => m is EventFieldDeclarationSyntax); return lastEvent ?? LastField(members); } if (eventDeclaration.Kind() == SyntaxKind.EventDeclaration) { // Property style events go after existing events, then after existing constructors. var lastEvent = members.LastOrDefault(m => m is EventDeclarationSyntax); return lastEvent ?? LastConstructor(members); } return null; }
private static SyntaxNode UpdateSyntaxRoot(MemberDeclarationSyntax memberDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions) { var parentDeclaration = memberDeclaration.Parent; var memberToMove = new MemberOrderHelper(memberDeclaration, checks); if (parentDeclaration is TypeDeclarationSyntax) { return HandleTypeDeclaration(memberToMove, (TypeDeclarationSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions); } if (parentDeclaration is NamespaceDeclarationSyntax) { return HandleNamespaceDeclaration(memberToMove, (NamespaceDeclarationSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions); } if (parentDeclaration is CompilationUnitSyntax) { return HandleCompilationUnitDeclaration(memberToMove, (CompilationUnitSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions); } return syntaxRoot; }
static AddTruthinessMethods() { SyntaxTree parsed = SyntaxTree.ParseCompilationUnit( @" private static bool __Truthy(object o) { if (o == null || (o is string && (string)o == string.Empty)) return false; var type = o.GetType(); if (type.IsValueType) { return !o.Equals(Activator.CreateInstance(type)); } return true; } " ); TruthyMethod = parsed.Root.DescendentNodesAndSelf().OfType<MethodDeclarationSyntax>().Single(); }
private static SyntaxNode UpdateSyntaxRoot(MemberDeclarationSyntax memberDeclaration, ImmutableArray<OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationSettings indentationSettings) { var parentDeclaration = memberDeclaration.Parent; var memberToMove = new MemberOrderHelper(memberDeclaration, elementOrder); if (parentDeclaration is TypeDeclarationSyntax) { return HandleTypeDeclaration(memberToMove, (TypeDeclarationSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings); } if (parentDeclaration is NamespaceDeclarationSyntax) { return HandleNamespaceDeclaration(memberToMove, (NamespaceDeclarationSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings); } if (parentDeclaration is CompilationUnitSyntax) { return HandleCompilationUnitDeclaration(memberToMove, (CompilationUnitSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings); } return syntaxRoot; }
public static string GetAccessModifiers(MemberDeclarationSyntax member, bool isInterface) { bool isStatic; var acccessmodifiers = ""; var modifiers = member.GetModifiers(); bool isoverride = ShouldUseOverrideKeyword(member, isInterface); if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) || modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface) acccessmodifiers += ("public "); if (!modifiers.Any(SyntaxKind.VirtualKeyword) && !isInterface && !isoverride) acccessmodifiers += ("final "); /// if (modifiers.Any(SyntaxKind.PrivateKeyword)) // Reflection cannot work with this, cant get address or set value // acccessmodifiers += ("private "); if (modifiers.Any(SyntaxKind.StaticKeyword)) { acccessmodifiers += "static "; } if (member.GetModifiers().Any(SyntaxKind.AbstractKeyword)) acccessmodifiers += "abstract "; if (isoverride) acccessmodifiers += ("override "); return acccessmodifiers; }
public static SyntaxTriviaList Generate(MemberDeclarationSyntax memberDeclaration, DocumentationCommentGeneratorSettings settings = null) { if (memberDeclaration == null) { throw new ArgumentNullException(nameof(memberDeclaration)); } switch (memberDeclaration.Kind()) { case SyntaxKind.NamespaceDeclaration: return(Generate((NamespaceDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.ClassDeclaration: return(Generate((ClassDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.StructDeclaration: return(Generate((StructDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.InterfaceDeclaration: return(Generate((InterfaceDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.EnumDeclaration: return(Generate((EnumDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.DelegateDeclaration: return(Generate((DelegateDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.EnumMemberDeclaration: return(Generate((EnumMemberDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.FieldDeclaration: return(Generate((FieldDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.EventFieldDeclaration: return(Generate((EventFieldDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.MethodDeclaration: return(Generate((MethodDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.OperatorDeclaration: return(Generate((OperatorDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.ConversionOperatorDeclaration: return(Generate((ConversionOperatorDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.ConstructorDeclaration: return(Generate((ConstructorDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.DestructorDeclaration: return(Generate((DestructorDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.PropertyDeclaration: return(Generate((PropertyDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.EventDeclaration: return(Generate((EventDeclarationSyntax)memberDeclaration, settings)); case SyntaxKind.IndexerDeclaration: return(Generate((IndexerDeclarationSyntax)memberDeclaration, settings)); default: throw new ArgumentException("", nameof(memberDeclaration)); } }
private bool IsPublic(MemberDeclarationSyntax member) { return(member.Modifiers.Where(m => m.IsKind(SyntaxKind.PublicKeyword)).Any()); }
private static Accessibility GetAccessModifier(SyntaxNodeAnalysisContext context, MemberDeclarationSyntax declaration, SyntaxTokenList modifiers) { if (!modifiers.ContainsAccessModifier()) { if (modifiers.Any(SyntaxKind.PartialKeyword)) { if (!declaration.IsKind(SyntaxKind.MethodDeclaration)) { Accessibility?accessibility = GetPartialAccessModifier(context, declaration); if (accessibility != null) { if (accessibility == Accessibility.NotApplicable) { return(declaration.GetDefaultExplicitAccessibility()); } else { return(accessibility.Value); } } } } else { return(declaration.GetDefaultExplicitAccessibility()); } } return(Accessibility.NotApplicable); }
public static DocumentationCommentInserter Create(MemberDeclarationSyntax memberDeclaration) { return(Create(memberDeclaration.GetLeadingTrivia())); }
private static void HandleMemberDeclaration(SyntaxNodeAnalysisContext context) { MemberDeclarationSyntax memberSyntax = (MemberDeclarationSyntax)context.Node; var modifiers = memberSyntax.GetModifiers(); if (modifiers.Any(SyntaxKind.OverrideKeyword)) { return; } DocumentationCommentTriviaSyntax documentation = memberSyntax.GetDocumentationCommentTriviaSyntax(); if (documentation == null) { return; } Location location; ISymbol declaredSymbol = context.SemanticModel.GetDeclaredSymbol(memberSyntax, context.CancellationToken); if (declaredSymbol == null && memberSyntax.IsKind(SyntaxKind.EventFieldDeclaration)) { var eventFieldDeclarationSyntax = (EventFieldDeclarationSyntax)memberSyntax; VariableDeclaratorSyntax firstVariable = eventFieldDeclarationSyntax.Declaration?.Variables.FirstOrDefault(); if (firstVariable != null) { declaredSymbol = context.SemanticModel.GetDeclaredSymbol(firstVariable, context.CancellationToken); } } if (documentation.Content.GetFirstXmlElement(XmlCommentHelper.IncludeXmlTag) is XmlEmptyElementSyntax includeElement) { if (declaredSymbol == null) { return; } var rawDocumentation = declaredSymbol.GetDocumentationCommentXml(expandIncludes: true, cancellationToken: context.CancellationToken); var completeDocumentation = XElement.Parse(rawDocumentation, LoadOptions.None); var inheritDocElement = completeDocumentation.Nodes().OfType <XElement>().FirstOrDefault(element => element.Name == XmlCommentHelper.InheritdocXmlTag); if (inheritDocElement == null) { return; } if (HasXmlCrefAttribute(inheritDocElement)) { return; } location = includeElement.GetLocation(); } else { XmlNodeSyntax inheritDocElement = documentation.Content.GetFirstXmlElement(XmlCommentHelper.InheritdocXmlTag); if (inheritDocElement == null) { return; } if (HasXmlCrefAttribute(inheritDocElement)) { return; } location = inheritDocElement.GetLocation(); } // If we don't have a declared symbol we have some kind of field declaration. A field can not override or // implement anything so we want to report a diagnostic. if (declaredSymbol == null || !NamedTypeHelpers.IsImplementingAnInterfaceMember(declaredSymbol)) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, location)); } }
public static Accessibility GetDefaultAccessibility(this MemberDeclarationSyntax memberDeclaration) { if (memberDeclaration == null) { throw new ArgumentNullException(nameof(memberDeclaration)); } switch (memberDeclaration.Kind()) { case SyntaxKind.ConstructorDeclaration: { if (((ConstructorDeclarationSyntax)memberDeclaration).IsStatic()) { return(Accessibility.NotApplicable); } else { return(Accessibility.Private); } } case SyntaxKind.DestructorDeclaration: { return(Accessibility.NotApplicable); } case SyntaxKind.MethodDeclaration: { var methodDeclaration = (MethodDeclarationSyntax)memberDeclaration; if (methodDeclaration.Modifiers.Contains(SyntaxKind.PartialKeyword) || methodDeclaration.ExplicitInterfaceSpecifier != null || methodDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration)) { return(Accessibility.NotApplicable); } else { return(Accessibility.Private); } } case SyntaxKind.PropertyDeclaration: { var propertyDeclaration = (PropertyDeclarationSyntax)memberDeclaration; if (propertyDeclaration.ExplicitInterfaceSpecifier != null || propertyDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration)) { return(Accessibility.NotApplicable); } else { return(Accessibility.Private); } } case SyntaxKind.IndexerDeclaration: { var indexerDeclaration = (IndexerDeclarationSyntax)memberDeclaration; if (indexerDeclaration.ExplicitInterfaceSpecifier != null || indexerDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration)) { return(Accessibility.NotApplicable); } else { return(Accessibility.Private); } } case SyntaxKind.EventDeclaration: { var eventDeclaration = (EventDeclarationSyntax)memberDeclaration; if (eventDeclaration.ExplicitInterfaceSpecifier != null) { return(Accessibility.NotApplicable); } else { return(Accessibility.Private); } } case SyntaxKind.EventFieldDeclaration: { if (memberDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration)) { return(Accessibility.NotApplicable); } else { return(Accessibility.Private); } } case SyntaxKind.FieldDeclaration: { return(Accessibility.Private); } case SyntaxKind.OperatorDeclaration: case SyntaxKind.ConversionOperatorDeclaration: { return(Accessibility.Public); } case SyntaxKind.ClassDeclaration: case SyntaxKind.StructDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.EnumDeclaration: case SyntaxKind.DelegateDeclaration: { if (memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration)) { return(Accessibility.Private); } else { return(Accessibility.Internal); } } } return(Accessibility.NotApplicable); }
public static MemberDeclarationSyntax GetMemberAt(this MemberDeclarationSyntax declaration, int index) { SyntaxList <MemberDeclarationSyntax> members = GetMembers(declaration); return(members[index]); }
private static TDeclarationNode AddStatementsToMemberDeclaration <TDeclarationNode>(TDeclarationNode destinationMember, IEnumerable <SyntaxNode> statements, MemberDeclarationSyntax memberDeclaration) where TDeclarationNode : SyntaxNode { var body = memberDeclaration.GetBody(); if (body == null) { return(destinationMember); } var statementNodes = body.Statements.ToList(); statementNodes.AddRange(StatementGenerator.GenerateStatements(statements)); var finalBody = body.WithStatements(SyntaxFactory.List <StatementSyntax>(statementNodes)); var finalMember = memberDeclaration.WithBody(finalBody); return(Cast <TDeclarationNode>(finalMember)); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, YieldStatementSyntax yieldStatement) { if (context.IsAnyRefactoringEnabled( RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression, RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod, RefactoringIdentifiers.CreateConditionFromBooleanExpression) && yieldStatement.IsYieldReturn() && yieldStatement.Expression != null && context.SupportsSemanticModel) { if (context.IsAnyRefactoringEnabled( RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression, RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod)) { MemberDeclarationSyntax containingMember = ReturnExpressionRefactoring.GetContainingMethodOrPropertyOrIndexer(yieldStatement.Expression); if (containingMember != null) { TypeSyntax memberType = ReturnExpressionRefactoring.GetMemberType(containingMember); if (memberType != null) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol memberTypeSymbol = semanticModel .GetTypeInfo(memberType, context.CancellationToken) .Type; if (memberTypeSymbol?.SpecialType != SpecialType.System_Collections_IEnumerable) { ITypeSymbol typeSymbol = semanticModel .GetTypeInfo(yieldStatement.Expression, context.CancellationToken) .Type; if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression) && typeSymbol?.IsErrorType() == false && (memberTypeSymbol == null || memberTypeSymbol.IsErrorType() || !SyntaxAnalyzer.IsGenericIEnumerable(memberTypeSymbol) || !((INamedTypeSymbol)memberTypeSymbol).TypeArguments[0].Equals(typeSymbol))) { TypeSyntax newType = QualifiedName( ParseName("System.Collections.Generic"), GenericName( Identifier("IEnumerable"), TypeArgumentList( SingletonSeparatedList( CSharpFactory.Type(typeSymbol))))); context.RegisterRefactoring( $"Change {ReturnExpressionRefactoring.GetText(containingMember)} type to 'IEnumerable<{typeSymbol.ToDisplayString(SyntaxUtility.DefaultSymbolDisplayFormat)}>'", cancellationToken => { return(ChangeTypeRefactoring.ChangeTypeAsync( context.Document, memberType, newType, cancellationToken)); }); } if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod) && yieldStatement.Expression.Span.Contains(context.Span) && memberTypeSymbol?.IsNamedType() == true) { var namedTypeSymbol = (INamedTypeSymbol)memberTypeSymbol; if (namedTypeSymbol.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T) { ITypeSymbol argumentSymbol = namedTypeSymbol.TypeArguments[0]; if (argumentSymbol != typeSymbol) { ModifyExpressionRefactoring.ComputeRefactoring( context, yieldStatement.Expression, argumentSymbol, semanticModel); } } } } } } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.CreateConditionFromBooleanExpression)) { await CreateConditionFromBooleanExpressionRefactoring.ComputeRefactoringAsync(context, yieldStatement.Expression).ConfigureAwait(false); } } }
private ClassDeclarationSyntax GenerateRequestType(SourceFileContext ctx) { var baseType = ctx.Type(Typ.Generic(Package.GenericBaseRequestTypDef, ResponseTyp)); var cls = Class(Modifier.Public, RequestTyp, baseType); if (_restMethod.Description is object) { cls = cls.WithXmlDoc(XmlDoc.Summary(_restMethod.Description)); } using (ctx.InClass(RequestTyp)) { // Service and optionally "body" var serviceParam = Parameter(ctx.Type <IClientService>(), "service"); ParameterSyntax bodyParam = null; var extraParameters = new List <ParameterSyntax> { serviceParam }; var bodyDeclarations = new MemberDeclarationSyntax[0]; if (BodyTyp is object) { var bodyProperty = AutoProperty(Modifier.None, ctx.Type(BodyTyp), "Body", hasSetter: true) .WithXmlDoc(XmlDoc.Summary("Gets or sets the body of this request.")); var bodyMethod = Method(Modifier.Protected | Modifier.Override, ctx.Type <object>(), "GetBody")() .WithBody(Return(bodyProperty)) .WithXmlDoc(XmlDoc.Summary("Returns the body of the request.")); bodyDeclarations = new MemberDeclarationSyntax[] { bodyProperty, bodyMethod }; bodyParam = Parameter(ctx.Type(BodyTyp), "body"); extraParameters.Add(bodyParam); } var mediaDownloaderProperty = SupportsMediaDownload ? AutoProperty(Modifier.Public, ctx.Type <IMediaDownloader>(), "MediaDownloader", hasSetter: true, setterIsPrivate: true) .WithXmlDoc(XmlDoc.Summary("Gets the media downloader.")) : null; var parameters = CreateParameterList(RequestTyp); var requiredParameters = parameters .TakeWhile(p => p.IsRequired) .Select(p => (param: p, decl: Parameter(ctx.Type(p.Typ), p.CodeParameterName))) .ToList(); var assignments = requiredParameters .Select(p => Field(0, ctx.Type(p.param.Typ), p.param.PropertyName).Assign(p.decl)).ToList(); if (BodyTyp is object) { var bodyProperty = (PropertyDeclarationSyntax)bodyDeclarations[0]; assignments.Add(bodyProperty.Assign(bodyParam)); } if (SupportsMediaDownload) { assignments.Add(mediaDownloaderProperty.Assign(New(ctx.Type <MediaDownloader>())(serviceParam))); } var allCtorParameters = extraParameters.Concat(requiredParameters.Select(p => p.decl)).ToArray(); var ctor = Ctor(Modifier.Public, cls, BaseInitializer(serviceParam))(allCtorParameters) .WithXmlDoc(XmlDoc.Summary($"Constructs a new {PascalCasedName} request.")) .WithBlockBody(assignments.Concat <object>(new[] { InvocationExpression(IdentifierName("InitParameters")) }).ToArray()); var methodName = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "MethodName") .WithGetBody(Name) .WithXmlDoc(XmlDoc.Summary("Gets the method name.")); var httpMethod = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "HttpMethod") .WithGetBody(_restMethod.HttpMethod) .WithXmlDoc(XmlDoc.Summary("Gets the HTTP method.")); var restPath = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "RestPath") .WithGetBody(_restMethod.Path) .WithXmlDoc(XmlDoc.Summary("Gets the REST path.")); var initParameters = Method(Modifier.Protected | Modifier.Override, VoidType, "InitParameters")() .WithBlockBody( BaseExpression().Call("InitParameters")(), parameters.Select(p => p.GenerateInitializer(ctx)).ToArray()) .WithXmlDoc(XmlDoc.Summary($"Initializes {PascalCasedName} parameter list.")); // TODO: Media downloader members cls = cls.AddMembers(ctor); cls = cls.AddMembers(parameters.SelectMany(p => p.GenerateDeclarations(ctx)).ToArray()); cls = cls.AddMembers(bodyDeclarations); cls = cls.AddMembers(methodName, httpMethod, restPath, initParameters); if (SupportsMediaDownload) { cls = cls.AddMembers(mediaDownloaderProperty); cls = AddMediaDownloadMethods(mediaDownloaderProperty, cls, ctx); } } return(cls); }
/// <summary> /// Add the field and respect StyleCop ordering. /// </summary> /// <param name="generator">The <see cref="SyntaxGenerator"/>.</param> /// <param name="containingType">The containing type.</param> /// <param name="member">The <see cref="MemberDeclarationSyntax"/>.</param> /// <param name="comparer">The <see cref="IComparer{MemberDeclarationSyntax}"/>. If null <see cref="MemberDeclarationComparer.Default"/> is used.</param> /// <returns>The <paramref name="containingType"/> with <paramref name="member"/>.</returns> public static TypeDeclarationSyntax AddSorted(this SyntaxGenerator generator, TypeDeclarationSyntax containingType, MemberDeclarationSyntax member, IComparer <MemberDeclarationSyntax>?comparer = null) { if (generator is null) { throw new System.ArgumentNullException(nameof(generator)); } if (containingType is null) { throw new System.ArgumentNullException(nameof(containingType)); } if (member is null) { throw new System.ArgumentNullException(nameof(member)); } comparer ??= MemberDeclarationComparer.Default; if (!member.HasLeadingTrivia) { member = member.WithLeadingTrivia(SyntaxFactory.Whitespace(containingType.LeadingWhitespace() + " ")); } #pragma warning disable CA1062 // Already checked if (!member.HasTrailingTrivia) #pragma warning restore CA1062 // Validate arguments of public methods { member = member.WithTrailingLineFeed(); } for (var i = 0; i < containingType.Members.Count; i++) { var existing = containingType.Members[i]; if (comparer.Compare(member, existing) < 0) { if (TryMoveDirectives(existing.GetFirstToken(), member, out var token, out var memberWithDirectives)) { containingType = (TypeDeclarationSyntax)generator.InsertNodesBefore( containingType, existing, new[] { memberWithDirectives }); return(containingType.ReplaceToken(containingType.Members[i + 1].GetFirstToken(), token)); } if (containingType.Members.TryElementAt(i - 1, out var last) && ShouldAddLeadingLineFeed(last, member)) { member = member.WithLeadingLineFeed(); } if (ShouldAddLeadingLineFeed(member, existing)) { containingType = (TypeDeclarationSyntax)generator.ReplaceNode(containingType, containingType.Members[i], existing.WithLeadingLineFeed()); } #pragma warning disable CA1062 /// Already checked return((TypeDeclarationSyntax)generator.InsertNodesBefore(containingType, containingType.Members[i], new[] { member })); #pragma warning restore CA1062 // Validate arguments of public methods } } if (TryMoveDirectives(containingType.CloseBraceToken, member, out var closeBraceToken, out var memberWithDirective)) { containingType = (TypeDeclarationSyntax)generator.AddMembers( containingType, memberWithDirective); return(containingType.ReplaceToken(containingType.CloseBraceToken, closeBraceToken)); }
private static SyntaxNode Refactor(MemberDeclarationSyntax member) { switch (member.Parent.Kind()) { case SyntaxKind.CompilationUnit: { var parent = (CompilationUnitSyntax)member.Parent; SyntaxList <MemberDeclarationSyntax> members = parent.Members; int index = members.IndexOf(member); return(parent.WithMembers(members.Insert(index + 1, member))); } case SyntaxKind.NamespaceDeclaration: { var parent = (NamespaceDeclarationSyntax)member.Parent; SyntaxList <MemberDeclarationSyntax> members = parent.Members; int index = members.IndexOf(member); if (index == 0 && parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine()) { member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLineTrivia())); } return(parent.WithMembers(members.Insert(index + 1, member))); } case SyntaxKind.ClassDeclaration: { var parent = (ClassDeclarationSyntax)member.Parent; SyntaxList <MemberDeclarationSyntax> members = parent.Members; int index = members.IndexOf(member); if (index == 0 && parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine()) { member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLineTrivia())); } return(parent.WithMembers(members.Insert(index + 1, member))); } case SyntaxKind.StructDeclaration: { var parent = (StructDeclarationSyntax)member.Parent; SyntaxList <MemberDeclarationSyntax> members = parent.Members; int index = members.IndexOf(member); if (index == 0 && parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine()) { member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLineTrivia())); } return(parent.WithMembers(members.Insert(index + 1, member))); } case SyntaxKind.InterfaceDeclaration: { var parent = (InterfaceDeclarationSyntax)member.Parent; SyntaxList <MemberDeclarationSyntax> members = parent.Members; int index = members.IndexOf(member); if (index == 0 && parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine()) { member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLineTrivia())); } return(parent.WithMembers(members.Insert(index + 1, member))); } } return(null); }
private void ProcessMemberDeclaration( SyntaxTreeAnalysisContext context, CodeStyleOption2 <AccessibilityModifiersRequired> option, MemberDeclarationSyntax member) { if (member.IsKind(SyntaxKind.NamespaceDeclaration, out NamespaceDeclarationSyntax namespaceDeclaration)) { ProcessMembers(context, option, namespaceDeclaration.Members); } // If we have a class or struct, recurse inwards. if (member.IsKind(SyntaxKind.ClassDeclaration, out TypeDeclarationSyntax typeDeclaration) || member.IsKind(SyntaxKind.StructDeclaration, out typeDeclaration) || member.IsKind(SyntaxKind.RecordDeclaration, out typeDeclaration)) { ProcessMembers(context, option, typeDeclaration.Members); } #if false // Add this once we have the language version for C# that supports accessibility // modifiers on interface methods. if (option.Value == AccessibilityModifiersRequired.Always && member.IsKind(SyntaxKind.InterfaceDeclaration, out typeDeclaration)) { // Only recurse into an interface if the user wants accessibility modifiers on ProcessTypeDeclaration(context, generator, option, typeDeclaration); } #endif // Have to have a name to report the issue on. var name = member.GetNameToken(); if (name.Kind() == SyntaxKind.None) { return; } // Certain members never have accessibility. Don't bother reporting on them. if (!SyntaxFacts.CanHaveAccessibility(member)) { return; } // This analyzer bases all of its decisions on the accessibility var accessibility = SyntaxFacts.GetAccessibility(member); // Omit will flag any accessibility values that exist and are default // The other options will remove or ignore accessibility var isOmit = option.Value == AccessibilityModifiersRequired.OmitIfDefault; if (isOmit) { if (accessibility == Accessibility.NotApplicable) { return; } var parentKind = member.Parent.Kind(); switch (parentKind) { // Check for default modifiers in namespace and outside of namespace case SyntaxKind.CompilationUnit: case SyntaxKind.NamespaceDeclaration: { // Default is internal if (accessibility != Accessibility.Internal) { return; } } break; case SyntaxKind.ClassDeclaration: case SyntaxKind.RecordDeclaration: case SyntaxKind.StructDeclaration: { // Inside a type, default is private if (accessibility != Accessibility.Private) { return; } } break; default: return; // Unknown parent kind, don't do anything } } else { // Mode is always, so we have to flag missing modifiers if (accessibility != Accessibility.NotApplicable) { return; } } // Have an issue to flag, either add or remove. Report issue to user. var additionalLocations = ImmutableArray.Create(member.GetLocation()); context.ReportDiagnostic(DiagnosticHelper.Create( Descriptor, name.GetLocation(), option.Notification.Severity, additionalLocations: additionalLocations, properties: null)); }
public static LocalDeclarationMap GetLocalDeclarationMap(this MemberDeclarationSyntax member) { var result = s_declarationCache.GetValue(member, s_createLocalDeclarationMap); return(new LocalDeclarationMap(result)); }
private static void RegisterRefactoring(RefactoringContext context, MemberDeclarationSyntax memberDeclaration, BaseDocumentationCommentData data) { context.RegisterRefactoring( GetTitle(memberDeclaration, data.Origin), cancellationToken => RefactorAsync(context.Document, memberDeclaration, data.Comment, cancellationToken)); }
private static Dictionary <string, ImmutableArray <SyntaxToken> > CreateLocalDeclarationMap(MemberDeclarationSyntax member) { var dictionary = DeclarationFinder.GetAllDeclarations(member); return(dictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.AsImmutable <SyntaxToken>())); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberDeclarationSyntax declaration) { if (!context.IsRefactoringEnabled(RefactoringIdentifiers.IntroduceConstructor)) { return; } List <MemberDeclarationSyntax> members = null; SyntaxKind kind = declaration.Kind(); if (kind.Is(SyntaxKind.PropertyDeclaration, SyntaxKind.FieldDeclaration)) { if (context.Span.Contains(declaration.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); if (CanBeAssignedFromConstructor(declaration, context.Span, semanticModel, context.CancellationToken)) { members = new List <MemberDeclarationSyntax>() { declaration }; } } } else if (kind.Is(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration)) { SemanticModel semanticModel = null; foreach (MemberDeclarationSyntax member in SyntaxInfo.MemberDeclarationListInfo(declaration).Members) { if (context.Span.Contains(member.Span)) { if (semanticModel == null) { semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); } if (CanBeAssignedFromConstructor(member, context.Span, semanticModel, context.CancellationToken)) { (members ??= new List <MemberDeclarationSyntax>()).Add(member); } } } } if (members == null) { return; } context.RegisterRefactoring( "Introduce constructor", ct => RefactorAsync(context.Document, declaration, members, ct), RefactoringIdentifiers.IntroduceConstructor); }
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxList <MemberDeclarationSyntax> members) { int count = members.Count; if (count <= 1) { return; } SyntaxTree tree = context.Node.SyntaxTree; bool?isPrevSingleLine = null; for (int i = 1; i < count; i++) { MemberDeclarationSyntax prevMember = members[i - 1]; SyntaxTriviaList trailingTrivia = prevMember.GetTrailingTrivia(); SyntaxTrivia lastTrailingTrivia = trailingTrivia.LastOrDefault(); if (!lastTrailingTrivia.IsKind(SyntaxKind.EndOfLineTrivia)) { isPrevSingleLine = false; continue; } MemberDeclarationSyntax member = members[i]; SyntaxTrivia documentationCommentTrivia = member.GetDocumentationCommentTrivia(); bool hasDocumentationComment = !documentationCommentTrivia.IsKind(SyntaxKind.None); if (!hasDocumentationComment) { bool isSingleLine = tree.IsSingleLineSpan(member.Span, context.CancellationToken); if (isSingleLine) { if (isPrevSingleLine == null) { isPrevSingleLine = tree.IsSingleLineSpan(prevMember.Span, context.CancellationToken); } if (isPrevSingleLine == true) { isPrevSingleLine = isSingleLine; continue; } } isPrevSingleLine = isSingleLine; } else { isPrevSingleLine = null; } if (member .GetLeadingTrivia() .FirstOrDefault() .IsKind(SyntaxKind.EndOfLineTrivia)) { continue; } int end = (hasDocumentationComment) ? documentationCommentTrivia.SpanStart : member.SpanStart; if (tree.GetLineCount(TextSpan.FromBounds(prevMember.Span.End, end), context.CancellationToken) == 2) { DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.AddEmptyLineBetweenDeclarations, lastTrailingTrivia); } } }
private static CompilationResult CompileInternal(string originalName, string cSharpSafeName, MemberDeclarationSyntax @class, bool isIndex, Dictionary <string, string> extentions = null) { var name = cSharpSafeName + "." + Guid.NewGuid() + (isIndex ? IndexExtension : TransformerExtension); var @namespace = RoslynHelper.CreateNamespace(isIndex ? IndexNamespace : TransformerNamespace) .WithMembers(SyntaxFactory.SingletonList(@class)); var res = GetUsingDirectiveAndSyntaxTreesAndRefrences(extentions); var compilationUnit = SyntaxFactory.CompilationUnit() .WithUsings(RoslynHelper.CreateUsings(res.UsingDirectiveSyntaxes)) .WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(@namespace)) .NormalizeWhitespace(); SyntaxNode formatedCompilationUnit; using (var workspace = new AdhocWorkspace()) { formatedCompilationUnit = Formatter.Format(compilationUnit, workspace); } string sourceFile = null; if (EnableDebugging) { sourceFile = Path.Combine(Path.GetTempPath(), name + ".cs"); File.WriteAllText(sourceFile, formatedCompilationUnit.ToFullString(), Encoding.UTF8); } var st = EnableDebugging ? SyntaxFactory.ParseSyntaxTree(File.ReadAllText(sourceFile), path: sourceFile, encoding: Encoding.UTF8) : SyntaxFactory.ParseSyntaxTree(formatedCompilationUnit.ToFullString()); res.SyntaxTrees.Add(st); var syntaxTrees = res.SyntaxTrees; var compilation = CSharpCompilation.Create( assemblyName: name + ".dll", syntaxTrees: syntaxTrees, references: res.References, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) .WithOptimizationLevel(OptimizationLevel.Release) ); var code = formatedCompilationUnit.SyntaxTree.ToString(); var asm = new MemoryStream(); var pdb = EnableDebugging ? new MemoryStream() : null; var result = compilation.Emit(asm, pdb, options: new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb)); if (result.Success == false) { IEnumerable <Diagnostic> failures = result.Diagnostics .Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); var sb = new StringBuilder(); sb.AppendLine($"Failed to compile {(isIndex ? "index" : "transformer")} {originalName}"); sb.AppendLine(); sb.AppendLine(code); sb.AppendLine(); foreach (var diagnostic in failures) { sb.AppendLine(diagnostic.ToString()); } if (isIndex) { throw new IndexCompilationException(sb.ToString()); } throw new TransformerCompilationException(sb.ToString()); } asm.Position = 0; Assembly assembly; if (EnableDebugging) { pdb.Position = 0; assembly = AssemblyLoadContext.Default.LoadFromStream(asm, pdb); } else { assembly = AssemblyLoadContext.Default.LoadFromStream(asm); } return(new CompilationResult { Code = code, Type = assembly.GetType($"{(isIndex ? IndexNamespace : TransformerNamespace)}.{cSharpSafeName}") }); }
public static bool IsProtected(this MemberDeclarationSyntax field) => field.HasModifier(ProtectedKeyword);
private static void AnalyzeLogicalNotExpression(SyntaxNodeAnalysisContext context) { var logicalNot = (PrefixUnaryExpressionSyntax)context.Node; ExpressionSyntax expression = logicalNot.Operand?.WalkDownParentheses(); if (expression?.IsMissing != false) { return; } switch (expression.Kind()) { case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: case SyntaxKind.LogicalNotExpression: { ReportDiagnostic(); break; } case SyntaxKind.EqualsExpression: { MemberDeclarationSyntax memberDeclaration = logicalNot.FirstAncestor <MemberDeclarationSyntax>(); if (memberDeclaration is OperatorDeclarationSyntax operatorDeclaration && operatorDeclaration.OperatorToken.IsKind(SyntaxKind.ExclamationEqualsToken)) { return; } ReportDiagnostic(); break; } case SyntaxKind.NotEqualsExpression: { MemberDeclarationSyntax memberDeclaration = logicalNot.FirstAncestor <MemberDeclarationSyntax>(); if (memberDeclaration is OperatorDeclarationSyntax operatorDeclaration && operatorDeclaration.OperatorToken.IsKind(SyntaxKind.EqualsEqualsToken)) { return; } ReportDiagnostic(); break; } case SyntaxKind.LessThanExpression: case SyntaxKind.LessThanOrEqualExpression: case SyntaxKind.GreaterThanExpression: case SyntaxKind.GreaterThanOrEqualExpression: { var binaryExpression = (BinaryExpressionSyntax)expression; if (IsNumericType(binaryExpression.Left, context.SemanticModel, context.CancellationToken) && IsNumericType(binaryExpression.Right, context.SemanticModel, context.CancellationToken)) { ReportDiagnostic(); } break; } } void ReportDiagnostic() { DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.SimplifyLogicalNegation, logicalNot); } }
public static bool IsConstant(this MemberDeclarationSyntax member) => member.HasModifier(ConstKeyword);
public static void MemberDeclarationComparerCompare(MemberDeclarationSyntax x, MemberDeclarationSyntax y) { Assert.AreEqual(-1, MemberDeclarationComparer.Compare(x, y)); Assert.AreEqual(1, MemberDeclarationComparer.Compare(y, x)); Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x)); Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y)); }
private static bool IsEmptyMethod(MemberDeclarationSyntax node) => node is MethodDeclarationSyntax methodDeclarationSyntax &&
public static bool IsPublic(this MemberDeclarationSyntax field) => field.HasModifier(PublicKeyword);
public static CompilationUnitSyntax RemoveMember(CompilationUnitSyntax compilationUnit, MemberDeclarationSyntax member) { if (compilationUnit == null) { throw new ArgumentNullException(nameof(compilationUnit)); } if (member == null) { throw new ArgumentNullException(nameof(member)); } int index = compilationUnit.Members.IndexOf(member); MemberDeclarationSyntax newMember = RemoveSingleLineDocumentationComment(member); compilationUnit = compilationUnit.WithMembers(compilationUnit.Members.ReplaceAt(index, newMember)); return(compilationUnit.RemoveNode(compilationUnit.Members[index], GetRemoveOptions(newMember))); }
public static InterfaceDeclarationSyntax RemoveMember(InterfaceDeclarationSyntax interfaceDeclaration, MemberDeclarationSyntax member) { if (interfaceDeclaration == null) { throw new ArgumentNullException(nameof(interfaceDeclaration)); } if (member == null) { throw new ArgumentNullException(nameof(member)); } int index = interfaceDeclaration.Members.IndexOf(member); MemberDeclarationSyntax newMember = RemoveSingleLineDocumentationComment(member); interfaceDeclaration = interfaceDeclaration.WithMembers(interfaceDeclaration.Members.ReplaceAt(index, newMember)); return(interfaceDeclaration.RemoveNode(interfaceDeclaration.Members[index], GetRemoveOptions(newMember))); }
public override void ExitFoxmethod([NotNull] XP.FoxmethodContext context) { context.SetSequencePoint(context.T.Start, context.end.Stop); var idName = context.Id.Get <SyntaxToken>(); var mods = context.Modifiers?.GetList <SyntaxToken>() ?? DefaultMethodModifiers(false, false, context.TypeParameters != null); var isExtern = mods.Any((int)SyntaxKind.ExternKeyword); var isAbstract = mods.Any((int)SyntaxKind.AbstractKeyword); var hasNoBody = isExtern || isAbstract; var mName = idName.Text; if (mName.EndsWith("_ACCESS", StringComparison.OrdinalIgnoreCase)) { mName = mName.Substring(0, mName.Length - "_ACCESS".Length); } else if (mName.EndsWith("_ASSIGN", StringComparison.OrdinalIgnoreCase)) { mName = mName.Substring(0, mName.Length - "_ASSIGN".Length); } idName = SyntaxFactory.MakeIdentifier(mName); bool isAccessAssign = this.isAccessAssign(context.RealType); var attributes = context.Attributes?.GetList <AttributeListSyntax>() ?? EmptyList <AttributeListSyntax>(); bool hasExtensionAttribute = false; if (isAccessAssign) { var vomods = _pool.Allocate(); vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.PrivateKeyword)); if (mods.Any((int)SyntaxKind.StaticKeyword)) { vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.StaticKeyword)); } if (mods.Any((int)SyntaxKind.UnsafeKeyword)) { vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.UnsafeKeyword)); } mods = vomods.ToList <SyntaxToken>(); _pool.Free(vomods); } if (!isExtern) { isExtern = hasDllImport(attributes); hasNoBody = hasNoBody || isExtern; } if (isExtern && !mods.Any((int)SyntaxKind.ExternKeyword)) { // Add Extern Keyword to modifiers var m1 = _pool.Allocate(); m1.AddRange(mods); if (!m1.Any((int)SyntaxKind.ExternKeyword)) { m1.Add(SyntaxFactory.MakeToken(SyntaxKind.ExternKeyword)); } mods = m1.ToList <SyntaxToken>(); _pool.Free(m1); } var parameters = context.ParamList?.Get <ParameterListSyntax>() ?? EmptyParameterList(); var body = hasNoBody ? null : context.StmtBlk.Get <BlockSyntax>(); var returntype = context.Type?.Get <TypeSyntax>(); if (returntype == null) { if (context.RealType == XP.ASSIGN) { returntype = VoidType(); } else // method and access { returntype = _getMissingType(); returntype.XNode = context; } } else { returntype.XVoDecl = true; } var oldbody = body; ImplementClipperAndPSZ(context, ref attributes, ref parameters, ref body, ref returntype); if (body != oldbody) { context.StmtBlk.Put(body); } if (context.RealType == XP.ASSIGN) { // Assign does not need a return. // So do not add missing returns returntype = VoidType(); } else if (context.StmtBlk != null && !hasNoBody) { body = AddMissingReturnStatement(body, context.StmtBlk, returntype); } MemberDeclarationSyntax m = _syntaxFactory.MethodDeclaration( attributeLists: attributes, modifiers: mods, returnType: returntype, explicitInterfaceSpecifier: null, identifier: idName, typeParameterList: context.TypeParameters?.Get <TypeParameterListSyntax>(), parameterList: parameters, constraintClauses: MakeList <TypeParameterConstraintClauseSyntax>(context._ConstraintsClauses), body: body, expressionBody: null, // TODO: (grammar) expressionBody methods semicolonToken: (!hasNoBody && context.StmtBlk != null) ? null : SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken)); if (hasExtensionAttribute) { m = m.WithAdditionalDiagnostics(new SyntaxDiagnosticInfo(ErrorCode.ERR_ExplicitExtension)); } bool separateMethod = false; context.Put(m); if (isAccessAssign && !separateMethod) { if (context.Data.HasClipperCallingConvention && context.CallingConvention != null) { m = m.WithAdditionalDiagnostics(new SyntaxDiagnosticInfo( ErrorCode.ERR_NoClipperCallingConventionForAccessAssign)); } context.Put(m); ClassEntities.Peek().AddVoPropertyAccessor(context, context.RealType, idName); } }
public static MemberDeclarationSyntax SetModifiers(this MemberDeclarationSyntax declaration, SyntaxTokenList modifiers) { if (declaration == null) { throw new ArgumentNullException(nameof(declaration)); } switch (declaration.Kind()) { case SyntaxKind.ClassDeclaration: return(((ClassDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.ConstructorDeclaration: return(((ConstructorDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.OperatorDeclaration: return(((OperatorDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.ConversionOperatorDeclaration: return(((ConversionOperatorDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.DelegateDeclaration: return(((DelegateDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.DestructorDeclaration: return(((DestructorDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.EnumDeclaration: return(((EnumDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.EventDeclaration: return(((EventDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.EventFieldDeclaration: return(((EventFieldDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.FieldDeclaration: return(((FieldDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.IndexerDeclaration: return(((IndexerDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.InterfaceDeclaration: return(((InterfaceDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.MethodDeclaration: return(((MethodDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.PropertyDeclaration: return(((PropertyDeclarationSyntax)declaration).WithModifiers(modifiers)); case SyntaxKind.StructDeclaration: return(((StructDeclarationSyntax)declaration).WithModifiers(modifiers)); default: { Debug.Assert(false, declaration.Kind().ToString()); return(declaration); } } }
public override void ExitFoxclass([NotNull] XP.FoxclassContext context) { var fieldNames = new List <String>(); var members = _pool.Allocate <MemberDeclarationSyntax>(); var generated = ClassEntities.Pop(); var mods = context.Modifiers?.GetList <SyntaxToken>() ?? TokenListWithDefaultVisibility(); context.Data.Partial = mods.Any((int)SyntaxKind.PartialKeyword); var baseTypes = _pool.AllocateSeparated <BaseTypeSyntax>(); var baseType = context.BaseType?.Get <TypeSyntax>(); if (baseType != null) { baseTypes.Add(_syntaxFactory.SimpleBaseType(baseType)); } if (generated.Members.Count > 0) { members.AddRange(generated.Members); } if (generated.VoProperties != null) { foreach (var vop in generated.VoProperties.Values) { var prop = GenerateVoProperty(vop, context); if (prop != null) { members.Add(prop); } } } // Collect list of FieldNames from clsvarscontext to prevent generating properties twice foreach (var mCtx in context._Members) { if (mCtx is XP.FoxclsvarsContext fcfc) { var mem = fcfc.Member; foreach (var v in mem._Vars) { fieldNames.Add(v.GetText().ToLower()); } var list = mem.CsNode as List <MemberDeclarationSyntax>; if (list != null) { foreach (var m1 in list) { members.Add(m1); } } } } // Do this after VOProps generation because GenerateVOProperty sets the members // for Access & Assign to NULL ConstructorDeclarationSyntax ctor = null; foreach (var mCtx in context._Members) { if (mCtx is XP.FoxclsvarinitContext cvi) { var fld = cvi.Member.F.Name.GetText(); if (!fieldNames.Contains(fld.ToLower())) { if (mCtx.CsNode != null) { members.Add(mCtx.Get <MemberDeclarationSyntax>()); } } else { // field is declared and initialized. No need to generate a second property or field. } } else if (mCtx is XP.FoximplementsContext fic) { var clause = fic.Member as XP.FoximplementsclauseContext; var type = clause.Type.Get <TypeSyntax>(); if (baseTypes.Count > 0) { baseTypes.AddSeparator(SyntaxFactory.MakeToken(SyntaxKind.CommaToken)); } baseTypes.Add(_syntaxFactory.SimpleBaseType(type)); } else if (mCtx is XP.FoxclsmethodContext cmc) { if (cmc.Member.CsNode is MemberDeclarationSyntax mds) { members.Add(mds); } } else if (mCtx is XP.FoxaddobjectContext fac) { var prop = fac.Get <MemberDeclarationSyntax>(); members.Add(prop); } else { if (mCtx.CsNode is MemberDeclarationSyntax mds) { members.Add(mds); if (mds is ConstructorDeclarationSyntax) { ctor = mds as ConstructorDeclarationSyntax; } } } } generated.Free(); if (ctor != null) { var newlist = members.ToList(); members.Clear(); foreach (var mem in newlist) { if (mem != ctor) { members.Add(mem); } } ctor = createConstructor(context, members, fieldNames, ctor); members.Add(ctor); } else { ctor = createConstructor(context, members, fieldNames, null); members.Add(ctor); } MemberDeclarationSyntax m = _syntaxFactory.ClassDeclaration( attributeLists: context.Attributes?.GetList <AttributeListSyntax>() ?? EmptyList <AttributeListSyntax>(), modifiers: mods, keyword: SyntaxFactory.MakeToken(SyntaxKind.ClassKeyword), identifier: context.Id.Get <SyntaxToken>(), typeParameterList: context.TypeParameters?.Get <TypeParameterListSyntax>(), baseList: _syntaxFactory.BaseList(SyntaxFactory.MakeToken(SyntaxKind.ColonToken), baseTypes), constraintClauses: MakeList <TypeParameterConstraintClauseSyntax>(context._ConstraintsClauses), openBraceToken: SyntaxFactory.MakeToken(SyntaxKind.OpenBraceToken), members: members, closeBraceToken: SyntaxFactory.MakeToken(SyntaxKind.CloseBraceToken), semicolonToken: null); _pool.Free(members); _pool.Free(baseTypes); if (context.Namespace != null) { m = AddNameSpaceToMember(context.Namespace, m); } else { m = (MemberDeclarationSyntax)CheckTypeName(context, "CLASS", m); } context.Put(m); if (context.Data.Partial) { GlobalEntities.NeedsProcessing = true; } }