public override TypeWithNode VisitTupleType(TupleTypeSyntax node)
{
var elementTypes = node.Elements.Select(e => e.Type.Accept(this)).ToArray();
var symbolInfo = semanticModel.GetSymbolInfo(node, cancellationToken);
return(new TypeWithNode(symbolInfo.Symbol as ITypeSymbol, typeSystem.ObliviousNode, elementTypes));
}
public static Doc Print(TupleTypeSyntax node)
{
return(Doc.Concat(
Token.Print(node.OpenParenToken),
SeparatedSyntaxList.Print(node.Elements, Node.Print, " "),
Token.Print(node.CloseParenToken)
));
}
private Doc PrintTupleTypeSyntax(TupleTypeSyntax node)
{
return(Concat(
this.PrintSyntaxToken(node.OpenParenToken),
this.PrintSeparatedSyntaxList(node.Elements, this.Print, " "),
this.PrintSyntaxToken(node.CloseParenToken)
));
}
public override Evaluation VisitTupleType(TupleTypeSyntax node)
{
foreach (TupleElementSyntax elementSyntax in node.Elements)
{
elementSyntax.Accept <Evaluation>(this);
}
return(base.VisitTupleType(node));
}
public override void VisitTupleType(TupleTypeSyntax node)
{
Information.Add(InfoExtractor.Info.TYPE, node);
foreach (TupleElementSyntax elementSyntax in node.Elements)
{
elementSyntax.Accept(this);
}
base.VisitTupleType(node);
}
private TupleExpressionSyntax CreateTupleExpression(TupleTypeSyntax typeNode) =>
SyntaxFactory.TupleExpression(
typeNode.OpenParenToken,
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrTokenList(
typeNode.Elements
.GetWithSeparators()
.Select(ConvertTupleTypeElementComponent)
)
),
typeNode.CloseParenToken
);
private static void AnalyzeTupleType(SyntaxNodeAnalysisContext context)
{
TupleTypeSyntax tupleExpressionSyntax = (TupleTypeSyntax)context.Node;
foreach (var element in tupleExpressionSyntax.Elements)
{
if (element.Identifier.Kind() == SyntaxKind.None)
{
context.ReportDiagnostic(Diagnostic.Create(Rule, element.GetLocation()));
}
}
}
public TypeStructure ConvertTypeStructure(TypeSyntax syntax)
{
return(syntax switch
{
PredefinedTypeSyntax ptSyntax => ToPredefinedIdentifierStructure(ptSyntax.Keyword.Text),
IdentifierNameSyntax inSyntax => ToIdentifierStructure(inSyntax, _typeLocator),
QualifiedNameSyntax qnSyntax => ToIdentifierStructure(qnSyntax),
GenericNameSyntax gnSyntax => ToGenericTypeStructure(gnSyntax),
ArrayTypeSyntax atSyntax => ToArrayTypeStructure(atSyntax),
PointerTypeSyntax ptSyntax => ToPointerTypeStructure(ptSyntax),
NullableTypeSyntax ntSyntax => ToNullableTypeStructure(ntSyntax),
TupleTypeSyntax ttSyntax => ToTupleTypeStructure(ttSyntax),
_ => throw new ArgumentException(syntax.GetType().ToString())
});
public static Task <Document> FixListAsync(
Document document,
TupleTypeSyntax tupleType,
ListFixMode fixMode = ListFixMode.Fix,
CancellationToken cancellationToken = default)
{
return(FixListAsync(
document,
tupleType,
tupleType.OpenParenToken,
tupleType.Elements,
fixMode,
cancellationToken));
}
public override void VisitTupleType(TupleTypeSyntax node)
{
if (!PreVisit(node))
{
return;
}
foreach (TupleElementSyntax elementSyntax in node.Elements)
{
elementSyntax.Accept(this);
}
base.VisitTupleType(node);
PostVisit(node);
}
public override SyntaxNode VisitTupleType(TupleTypeSyntax node)
{
var oldAlwaysSimplify = this.alwaysSimplify;
if (!this.alwaysSimplify)
{
this.alwaysSimplify = node.HasAnnotation(Simplifier.Annotation);
}
var result = SimplifyExpression(
node,
newNode: base.VisitTupleType(node),
simplifier: s_simplifyName);
this.alwaysSimplify = oldAlwaysSimplify;
return(result);
}
private static TupleSymbol BindTupleType(TupleTypeSyntax syntax, bool isReadOnly)
{
if (syntax == null || syntax.Types == null || syntax.Types.Count <= 0)
{
return(null);
}
var builder = ImmutableArray.CreateBuilder <TypeSymbol>();
foreach (var type in syntax.Types)
{
var boundType = BindTypeDescription(type, isReadOnly);
if (boundType == null)
{
return(null);
}
builder.Add(boundType);
}
return(new TupleSymbol(builder.ToImmutable()));
}
public TameTupleTypeSyntax(TupleTypeSyntax node)
{
Node = node;
AddChildren();
}
public override SyntaxNode VisitTupleType(TupleTypeSyntax node) => ProcessTypeSyntax(node);
/// <inheritdoc/>
public override SyntaxNode?VisitTupleType(TupleTypeSyntax node)
{
Context.ReportDiagnostic(TupleType, node);
return(base.VisitTupleType(node));
}
public override void VisitTupleType(TupleTypeSyntax node)
{
Log(node, "Unsupported Syntax !");
}
public override void VisitTupleType(TupleTypeSyntax node)
{
throw new NotImplementedException();
}
/// <inheritdoc/>
public override SyntaxNode?VisitTupleType(TupleTypeSyntax node)
{
Diagnostics.Add(TupleType, node);
return(base.VisitTupleType(node));
}
internal static bool IsTypeInContextWhichNeedsTupleNamesAttribute(this TupleTypeSyntax syntax)
{
Debug.Assert(syntax != null);
return(SyntaxFacts.IsInTypeOnlyContext(syntax) && IsInContextWhichNeedsTupleNamesAttribute(syntax));
}
// // Summary: // Called when the visitor visits a TupleTypeSyntax node. public virtual void VisitTupleType(TupleTypeSyntax node);
public override void VisitTupleType(TupleTypeSyntax node)
{
}
public override void VisitTupleType(TupleTypeSyntax node)
{
base.VisitTupleType(node);
}
