public override SyntaxNode VisitIncompleteMember(IncompleteMemberSyntax node) { if (!(node.Type is GenericNameSyntax baseNode) || IsClosedNode(baseNode)) { return(node); } var baseArguments = baseNode.TypeArgumentList.Arguments; if (baseArguments.Count == 0) { return(node); } // reconstruct all nodes except last var typeSyntaxes = DeconstructLastNode(baseNode, out var identifierName); for (int i = typeSyntaxes.Count - 2; i >= 0; i--) { var generic = typeSyntaxes[i].lastNode; var args = typeSyntaxes[i + 1].nodes; var syntaxList = SyntaxFactory.SeparatedList(args); var argSyntax = SyntaxFactory.TypeArgumentList(syntaxList); var resGeneric = SyntaxFactory.GenericName(generic.Identifier, argSyntax); typeSyntaxes[i].nodes.Add(resGeneric); } var resulterGeneric = typeSyntaxes[0].nodes.First() as GenericNameSyntax; var variableName = SyntaxFactory.VariableDeclarator(identifierName.Identifier); var variableDeclaration = SyntaxFactory.VariableDeclaration(resulterGeneric).AddVariables(variableName); var fieldDeclaration = SyntaxFactory.FieldDeclaration(variableDeclaration).WithModifiers(node.Modifiers); return(fieldDeclaration); }
internal static ModifierListInfo Create(IncompleteMemberSyntax incompleteMember) { if (incompleteMember == null) { return(Default); } return(new ModifierListInfo(incompleteMember, incompleteMember.Modifiers)); }
public override Evaluation VisitIncompleteMember(IncompleteMemberSyntax node) { foreach (AttributeListSyntax attributeList in node.AttributeLists) { attributeList.Accept <Evaluation>(this); } node.Type?.Accept <Evaluation>(this); return(base.VisitIncompleteMember(node)); }
public override void VisitIncompleteMember(IncompleteMemberSyntax node) { foreach (AttributeListSyntax attributeList in node.AttributeLists) { attributeList.Accept(this); } node.Type?.Accept(this); base.VisitIncompleteMember(node); }
/// <summary> /// Processes a base list. It is ignored, as they are not interesting to the overall overview. /// </summary> public static void ProcessNode(IncompleteMemberSyntax node, ItemCollection itemCollection, int?index = null) { var item = new TreeViewItem { Header = new TreeElement( node.Type.ToString(), node.Span, TreeImages.GetImage(ElementType.Unknown, GetModifiers(node))) }; AddOrInsert(itemCollection, item, index); }
public override SyntaxNode VisitIncompleteMember(IncompleteMemberSyntax node) { string typename = node.Type.ToString(); IDSLHandler dsl = ctx_.CreateDSL(typename); if (dsl != null) { pending_ = new ResolveDSLClass(dsl, ctx_, members_); return(null); } return(node); }
/// <summary> /// Add <paramref name="text"/> as attribute list to <paramref name="member"/>. /// </summary> /// <param name="member">The <see cref="IncompleteMemberSyntax"/>.</param> /// <param name="text"> /// The attribute text including start and end []. /// </param> /// <param name="adjustLeadingWhitespace">If true leading whitespace is adjusted to match <paramref name="member"/>.</param> /// <returns>The <paramref name="member"/> with docs in leading trivia.</returns> public static IncompleteMemberSyntax WithAttributeListText(this IncompleteMemberSyntax member, string text, bool adjustLeadingWhitespace = true) { if (member is null) { throw new System.ArgumentNullException(nameof(member)); } if (text is null) { throw new System.ArgumentNullException(nameof(text)); } return(member.WithAttributeList(Parse.AttributeList(text, adjustLeadingWhitespace ? member.LeadingWhitespace() : null))); }
/// <summary> /// Add the attribute list to the <see cref="IncompleteMemberSyntax"/>. /// </summary> /// <param name="member">The <see cref="IncompleteMemberSyntax"/>.</param> /// <param name="attributeList">The <see cref="AttributeListSyntax"/>.</param> /// <returns>The <paramref name="member"/> with <paramref name="attributeList"/> added.</returns> public static IncompleteMemberSyntax WithAttributeList(this IncompleteMemberSyntax member, AttributeListSyntax attributeList) { if (member is null) { throw new System.ArgumentNullException(nameof(member)); } if (attributeList is null) { throw new System.ArgumentNullException(nameof(attributeList)); } return(member.WithAttributeLists(member.AttributeLists.Add(attributeList))); }
public override void VisitIncompleteMember(IncompleteMemberSyntax node) { if (!PreVisit(node)) { return; } foreach (AttributeListSyntax attributeList in node.AttributeLists) { attributeList.Accept(this); } node.Type?.Accept(this); base.VisitIncompleteMember(node); PostVisit(node); }
public SyntaxNode rewrite(CSharpSyntaxRewriter transform, SyntaxNode node, out LookAheadAction action) { if (node is IncompleteMemberSyntax) { action = LookAheadAction.SUCCEDED; IncompleteMemberSyntax incomplete = (IncompleteMemberSyntax)node; string typeName = incomplete.Type.ToString(); string typeDef = field_.Declaration.Variables.First().Identifier.ToString(); var typeNode = SyntaxFactory.ParseTypeName(typeDef); ClassDeclarationSyntax parent = (ClassDeclarationSyntax)field_.Parent; ctx_.AddTypeInfo(parent.Identifier.ToString(), "typedefs", new Typedef(typeName, (TypeSyntax)ctx_.CompileType(typeNode, parent))); return(null); } action = LookAheadAction.FAILED; return(node); }
public override SyntaxNode VisitIncompleteMember(IncompleteMemberSyntax node) { SyntacticalExtension <SyntaxNode> extension = typeExtension(node); if (extension != null) { if (extension.Kind == ExtensionKind.Type) { _lookahead = MatchTypeExtension(node, extension); return(null); //remove the incomplete member } else { //td: error, incorrect extension (i.e. a code extension being used inside a type) return(null); } } return(node); //error, stop processing }
private Func <SyntaxNode, Scope, LookAheadResult> MatchTypeExtension(IncompleteMemberSyntax incomplete, SyntacticalExtension <SyntaxNode> extension) { return((node, scope) => { var resulSyntaxNode = node; if (node is ClassDeclarationSyntax) { ClassDeclarationSyntax clazz = (ClassDeclarationSyntax)node; clazz = clazz .WithAttributeLists(incomplete.AttributeLists) .WithModifiers(incomplete.Modifiers); resulSyntaxNode = extension.Handler(node, scope, extension); } //td: error?, expecting class return new LookAheadResult { Matched = resulSyntaxNode != null, Result = resulSyntaxNode }; }); }
public override void VisitIncompleteMember(IncompleteMemberSyntax node) { LogicalLineCount++; base.VisitIncompleteMember(node); }
public override void VisitIncompleteMember(IncompleteMemberSyntax node) => base.VisitIncompleteMember(node);
public override SyntaxNode VisitIncompleteMember(IncompleteMemberSyntax node) { node = (IncompleteMemberSyntax)base.VisitIncompleteMember(node); Classes.Add(node); return(node); }
private Doc PrintIncompleteMemberSyntax(IncompleteMemberSyntax node) { return(string.Empty); // TODO 1 figure this out }
// // Summary: // Called when the visitor visits a IncompleteMemberSyntax node. public virtual void VisitIncompleteMember(IncompleteMemberSyntax node);
public override void VisitIncompleteMember(IncompleteMemberSyntax node) { throw new IncompleteCodeBlockException(); }
private SyntacticalExtension <SyntaxNode> typeExtension(IncompleteMemberSyntax node) { throw new NotImplementedException(); }
/// <summary> /// Creates a new <see cref="ModifierListInfo"/> with the specified modifiers updated. /// </summary> /// <param name="modifiers"></param> /// <returns></returns> public ModifierListInfo WithModifiers(SyntaxTokenList modifiers) { ThrowInvalidOperationIfNotInitialized(); switch (Parent.Kind()) { case SyntaxKind.ClassDeclaration: { var classDeclaration = (ClassDeclarationSyntax)Parent; ClassDeclarationSyntax newNode = classDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.ConstructorDeclaration: { var constructorDeclaration = (ConstructorDeclarationSyntax)Parent; ConstructorDeclarationSyntax newNode = constructorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.OperatorDeclaration: { var operatorDeclaration = (OperatorDeclarationSyntax)Parent; OperatorDeclarationSyntax newNode = operatorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.ConversionOperatorDeclaration: { var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)Parent; ConversionOperatorDeclarationSyntax newNode = conversionOperatorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.DelegateDeclaration: { var delegateDeclaration = (DelegateDeclarationSyntax)Parent; DelegateDeclarationSyntax newNode = delegateDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.DestructorDeclaration: { var destructorDeclaration = (DestructorDeclarationSyntax)Parent; DestructorDeclarationSyntax newNode = destructorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EnumDeclaration: { var enumDeclaration = (EnumDeclarationSyntax)Parent; EnumDeclarationSyntax newNode = enumDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EventDeclaration: { var eventDeclaration = (EventDeclarationSyntax)Parent; EventDeclarationSyntax newNode = eventDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EventFieldDeclaration: { var eventFieldDeclaration = (EventFieldDeclarationSyntax)Parent; EventFieldDeclarationSyntax newNode = eventFieldDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.FieldDeclaration: { var fieldDeclaration = (FieldDeclarationSyntax)Parent; FieldDeclarationSyntax newNode = fieldDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.IndexerDeclaration: { var indexerDeclaration = (IndexerDeclarationSyntax)Parent; IndexerDeclarationSyntax newNode = indexerDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.InterfaceDeclaration: { var interfaceDeclaration = (InterfaceDeclarationSyntax)Parent; InterfaceDeclarationSyntax newNode = interfaceDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.MethodDeclaration: { var methodDeclaration = (MethodDeclarationSyntax)Parent; MethodDeclarationSyntax newNode = methodDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.PropertyDeclaration: { var propertyDeclaration = (PropertyDeclarationSyntax)Parent; PropertyDeclarationSyntax newNode = propertyDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.StructDeclaration: { var structDeclaration = (StructDeclarationSyntax)Parent; StructDeclarationSyntax newNode = structDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.IncompleteMember: { var incompleteMember = (IncompleteMemberSyntax)Parent; IncompleteMemberSyntax newNode = incompleteMember.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.GetAccessorDeclaration: case SyntaxKind.SetAccessorDeclaration: case SyntaxKind.AddAccessorDeclaration: case SyntaxKind.RemoveAccessorDeclaration: case SyntaxKind.UnknownAccessorDeclaration: { var accessorDeclaration = (AccessorDeclarationSyntax)Parent; AccessorDeclarationSyntax newNode = accessorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.LocalDeclarationStatement: { var localDeclarationStatement = (LocalDeclarationStatementSyntax)Parent; LocalDeclarationStatementSyntax newNode = localDeclarationStatement.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.LocalFunctionStatement: { var localFunctionStatement = (LocalFunctionStatementSyntax)Parent; LocalFunctionStatementSyntax newNode = localFunctionStatement.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.Parameter: { var parameter = (ParameterSyntax)Parent; ParameterSyntax newNode = parameter.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } } throw new InvalidOperationException(); }
public TameIncompleteMemberSyntax(IncompleteMemberSyntax node) { Node = node; AddChildren(); }
public override void VisitIncompleteMember(IncompleteMemberSyntax node) { Log(node, "Unsupported Syntax !"); }
public override void VisitIncompleteMember(IncompleteMemberSyntax node) { base.VisitIncompleteMember(node); throw new SemanticViolationException($"Unrecognized syntax: {node}"); }
public override void VisitIncompleteMember(IncompleteMemberSyntax node) { base.VisitIncompleteMember(node); incompleteTokens.Add(node.ToFullString()); }
public static Doc Print(IncompleteMemberSyntax node) { return(string.Empty); }
public override void VisitIncompleteMember(IncompleteMemberSyntax node) { throw new NotImplementedException(); }
/// <summary> /// Creates a new <see cref="Syntax.ModifierListInfo"/> from the specified incomplete member. /// </summary> /// <param name="incompleteMember"></param> /// <returns></returns> public static ModifierListInfo ModifierListInfo(IncompleteMemberSyntax incompleteMember) { return(Syntax.ModifierListInfo.Create(incompleteMember)); }
// public override IEnumerable<MemberBinderContext> VisitConstructorInitializer(ConstructorInitializerSyntax node, object unused) // public override IEnumerable<MemberBinderContext> VisitDestructorDeclaration(DestructorDeclarationSyntax node, object unused) // public override IEnumerable<MemberBinderContext> VisitPropertyDeclaration(PropertyDeclarationSyntax node, object unused) // public override IEnumerable<MemberBinderContext> VisitEventDeclaration(EventDeclarationSyntax node, object unused) // public override IEnumerable<MemberBinderContext> VisitIndexerDeclaration(IndexerDeclarationSyntax node, object unused) public override IEnumerable <MemberBuilder> VisitIncompleteMember(IncompleteMemberSyntax node, object unused) { return(Enumerable.Empty <MemberBuilder>()); }
public static Doc Print(IncompleteMemberSyntax node) { return(string.Empty); // TODO 1 figure this out }
private SyntacticalExtension <SyntaxNode> typeExtension(IncompleteMemberSyntax node) { return(null); }