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);
}
