private SyntaxNode SimplifyDefaultExpression(
DefaultExpressionSyntax node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken
)
{
var preferSimpleDefaultExpression =
optionSet.GetOption(CSharpCodeStyleOptions.PreferSimpleDefaultExpression).Value;
if (
node.CanReplaceWithDefaultLiteral(
ParseOptions,
preferSimpleDefaultExpression,
semanticModel,
cancellationToken
)
)
{
return(SyntaxFactory
.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
.WithTriviaFrom(node));
}
return(node);
}
private static bool?CanReplaceWithDefaultLiteralFast(
DefaultExpressionSyntax defaultExpression, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (defaultExpression.IsParentKind(SyntaxKind.EqualsValueClause, out EqualsValueClauseSyntax equalsValueClause))
{
var typeSyntax = GetTypeSyntax(equalsValueClause);
if (typeSyntax != null)
{
if (typeSyntax.IsVar)
{
// If we have: var v = default(CancellationToken); then we can't simplify this.
return(false);
}
var entityType = semanticModel.GetTypeInfo(typeSyntax, cancellationToken).Type;
var defaultType = semanticModel.GetTypeInfo(defaultExpression.Type, cancellationToken).Type;
if (entityType != null && entityType.Equals(defaultType))
{
// We have a simple case of "CancellationToken c = default(CancellationToken)".
// We can just simplify without having to do any additional analysis.
return(true);
}
}
}
return(null);
}
private void Check(OperationAnalysisContext context, DefaultExpressionSyntax defaultExpression, INamedTypeSymbol symbol)
{
if (context.CancellationToken.IsCancellationRequested)
{
return;
}
if (symbol.OriginalDefinition.SpecialType != SpecialType.System_Nullable_T)
{
return;
}
if (!shouldReport(symbol))
{
return;
}
var model = context.Compilation.GetSemanticModel(defaultExpression.SyntaxTree);
var typeInfo = model.GetTypeInfo(defaultExpression);
if (Equals(typeInfo.Type, symbol.TypeArguments.FirstOrDefault()?.OriginalDefinition))
{
context.ReportDiagnostic(Diagnostic.Create(
SupportedDiagnostics[0],
defaultExpression.GetLocation(), SymbolDisplay.ToDisplayString(symbol,
SymbolDisplayFormat.CSharpShortErrorMessageFormat.WithParameterOptions(
SymbolDisplayParameterOptions.None))));
}
}
public override void VisitDefaultExpression(DefaultExpressionSyntax node)
{
var a = model.GetTypeInfo(node);
var b = model.GetTypeInfo(node.Type);
base.VisitDefaultExpression(node);
}
public override LuaSyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
{
var constExpression = GetConstExpression(node);
if (constExpression != null)
{
return(constExpression);
}
var type = semanticModel_.GetTypeInfo(node.Type).Type;
if (type.Kind != SymbolKind.TypeParameter)
{
if (type.IsValueType)
{
var expression = GetPredefinedDefaultValue(type);
return(expression ?? BuildDefaultValueExpression(node.Type));
}
else
{
return(LuaIdentifierLiteralExpressionSyntax.Nil);
}
}
else
{
return(BuildDefaultValueExpression(node.Type));
}
}
public override Ust VisitDefaultExpression(DefaultExpressionSyntax node)
{
var span = node.GetTextSpan();
var typeName = node.Type.ToString();
switch (typeName)
{
case "string":
case "char":
return(new StringLiteral("", span));
case "int":
case "uint":
case "sbyte":
case "byte":
case "short":
case "ushort":
case "long":
case "ulong":
return(new IntLiteral(0, span));
case "float":
case "double":
case "decimal":
return(new FloatLiteral(0.0, span));
case "bool":
default:
return(new NullLiteral(span));
}
}
public override JsExpression VisitDefaultExpression(DefaultExpressionSyntax node)
{
var type = model.GetTypeInfo(node).ConvertedType;
var jsMethodInfo = GetExpressionMethod("Default", Context.Instance.TypeType);
return(idioms.InvokeStatic(jsMethodInfo, idioms.TypeOf(type)));
}
public static bool CanReplaceWithDefaultLiteral(
this DefaultExpressionSyntax defaultExpression,
CSharpParseOptions parseOptions,
bool preferSimpleDefaultExpression,
SemanticModel semanticModel,
CancellationToken cancellationToken
)
{
if (
parseOptions.LanguageVersion < LanguageVersion.CSharp7_1 ||
!preferSimpleDefaultExpression
)
{
return(false);
}
// Using the speculation analyzer can be slow. Check for common cases first before
// trying the expensive path.
return(CanReplaceWithDefaultLiteralFast(
defaultExpression,
semanticModel,
cancellationToken
)
?? CanReplaceWithDefaultLiteralSlow(
defaultExpression,
semanticModel,
cancellationToken
));
}
public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
{
//Note: because we can not predict what T is, unless there is constraint on T said it's class or struct.
this.AppendCompileIssue(node, IssueType.Warning, IssueId.DefaultKeyword);
_output.Write(node, "null");
return(node);
}
public static void Write(this DefaultExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
textWriter.Write("_M.DV(");
var symbol = (ITypeSymbol)context.SemanticModel.GetSymbolInfo(syntax.Type).Symbol;
context.TypeReferenceWriter.WriteTypeReference(symbol, textWriter);
textWriter.Write(")");
}
public override IEnumerable <IModel> VisitDefaultExpression(DefaultExpressionSyntax node)
{
var model = Create <DefaultExpression>(node);
model.Type = GetDefinition <ITypeDefinition>(node.Type);
yield return(model);
}
public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
{
return(SimplifyNode(
node,
newNode: base.VisitDefaultExpression(node),
parentNode: node.Parent,
simplifier: _simplifyDefaultExpression));
}
/// <inheritdoc/>
public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
{
var updatedNode = (DefaultExpressionSyntax)base.VisitDefaultExpression(node) !;
updatedNode = updatedNode.ReplaceAndTrackType(updatedNode.Type, node.Type, SemanticModel.For(node), DiscoveredTypes);
// A default expression becomes (T)0 in HLSL
return(CastExpression(updatedNode.Type, LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0))));
}
public static Doc Print(DefaultExpressionSyntax node)
{
return(Doc.Concat(
Token.Print(node.Keyword),
Token.Print(node.OpenParenToken),
Node.Print(node.Type),
Token.Print(node.CloseParenToken)
));
}
private Doc PrintDefaultExpressionSyntax(DefaultExpressionSyntax node)
{
return(Concat(
this.PrintSyntaxToken(node.Keyword),
this.PrintSyntaxToken(node.OpenParenToken),
this.Print(node.Type),
this.PrintSyntaxToken(node.CloseParenToken)
));
}
private static Task <Document> SimplifyDefaultExpressionAsync(
Document document,
DefaultExpressionSyntax defaultExpression,
CancellationToken cancellationToken)
{
LiteralExpressionSyntax defaultLiteral = CSharpFactory.DefaultLiteralExpression().WithTrailingTrivia(defaultExpression.GetTrailingTrivia());
return(document.ReplaceNodeAsync(defaultExpression, defaultLiteral, cancellationToken));
}
public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
{
node = (DefaultExpressionSyntax)base.VisitDefaultExpression(node);
node = node.ReplaceType(node.Type);
CastExpressionSyntax castExpressionSyntax = SyntaxFactory.CastExpression(node.Type, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)));
return(SyntaxFactory.ParenthesizedExpression(castExpressionSyntax));
}
private static bool CanReplaceWithDefaultLiteralSlow(DefaultExpressionSyntax defaultExpression, SemanticModel semanticModel, CancellationToken cancellationToken)
{
var speculationAnalyzer = new SpeculationAnalyzer(
defaultExpression, s_defaultLiteralExpression, semanticModel,
cancellationToken,
skipVerificationForReplacedNode: false,
failOnOverloadResolutionFailuresInOriginalCode: true);
return(!speculationAnalyzer.ReplacementChangesSemantics());
}
public override SyntaxNode VisitVariableDeclaration(VariableDeclarationSyntax node)
{
node = (VariableDeclarationSyntax)base.VisitVariableDeclaration(node);
TypeSyntax type = node.Type;
SeparatedSyntaxList <VariableDeclaratorSyntax> declarations = node.Variables;
List <VariableDeclaratorSyntax> listOfVariables = new List <VariableDeclaratorSyntax>();
List <SyntaxToken> listOfSeperators = new List <SyntaxToken>();
if (transformKind == TransformKind.DefaultInitAllVars)
{
foreach (VariableDeclaratorSyntax decl in declarations)
{
if (decl.Initializer == null)
{
TypeSyntax newType = type;
if (newType.HasLeadingTrivia)
{
newType = newType.WithLeadingTrivia(new SyntaxTriviaList());
}
if (newType.HasTrailingTrivia)
{
newType = newType.WithLeadingTrivia(new SyntaxTriviaList());
}
SyntaxTrivia whiteSpaceTrivia = SyntaxFactory.Whitespace(" ");
DefaultExpressionSyntax defaultExpr = SyntaxFactory.DefaultExpression(newType);
EqualsValueClauseSyntax equalsClause = SyntaxFactory.EqualsValueClause(SyntaxFactory.Token(SyntaxFactory.TriviaList(whiteSpaceTrivia), SyntaxKind.EqualsToken, SyntaxFactory.TriviaList(whiteSpaceTrivia)), defaultExpr);
VariableDeclaratorSyntax newDecl = SyntaxFactory.VariableDeclarator(decl.Identifier, decl.ArgumentList, equalsClause);
listOfVariables.Add(newDecl);
}
else
{
listOfVariables.Add(decl);
}
}
for (int i = 0; i < declarations.SeparatorCount; i++)
{
SyntaxToken seperator = declarations.GetSeparator(i);
listOfSeperators.Add(SyntaxFactory.Token(seperator.LeadingTrivia, seperator.Kind(), seperator.TrailingTrivia));
}
SeparatedSyntaxList <VariableDeclaratorSyntax> seperatedSyntaxList = SyntaxFactory.SeparatedList(listOfVariables, listOfSeperators);
return(SyntaxFactory.VariableDeclaration(type, seperatedSyntaxList));
}
return(node);
}
private static SyntaxNode GetSemanticBoundary(DefaultExpressionSyntax node)
{
// Notes:
// 1. Syntax which doesn't fall into one of the "safe buckets" will get placed into a single group keyed off
// the root of the tree. If more than one such node exists in the document, all will be verified.
// 2. Cannot include ArgumentSyntax because it could affect generic argument inference.
return(node.FirstAncestorOrSelf <SyntaxNode>(n =>
n is StatementSyntax ||
n is ParameterSyntax ||
n is VariableDeclaratorSyntax ||
n.Parent == null));
}
public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
{
// reassociate trivia from open paren to type expression
node = node
.WithOpenParenToken(
node.OpenParenToken.WithTrailingTrivia(SyntaxTriviaList.Empty))
.WithType(
node.Type.WithLeadingTrivia(
node.OpenParenToken.TrailingTrivia.AddRange(node.Type.GetLeadingTrivia())));
node = (DefaultExpressionSyntax)base.VisitDefaultExpression(node);
return(node);
}
public override void VisitDefaultExpression(DefaultExpressionSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.Type?.Accept(this);
base.VisitDefaultExpression(node);
PostVisit(node);
}
private SyntaxNode SimplifyDefaultExpression(
DefaultExpressionSyntax node,
SemanticModel semanticModel,
OptionSet optionSet,
CancellationToken cancellationToken)
{
if (node.CanReplaceWithDefaultLiteral(ParseOptions, optionSet, semanticModel, cancellationToken))
{
return(SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
.WithTriviaFrom(node));
}
return(node);
}
private ProgramState VisitDefaultExpression(DefaultExpressionSyntax instruction, ProgramState programState)
{
var sv = new SymbolicValue();
var typeSymbol = SemanticModel.GetTypeInfo(instruction).Type;
var isReferenceOrNullable = typeSymbol.IsReferenceType ||
typeSymbol.OriginalDefinition.Is(KnownType.System_Nullable_T);
var newProgramState = isReferenceOrNullable
? programState.SetConstraint(sv, ObjectConstraint.Null)
: SetNonNullConstraintIfValueType(typeSymbol, sv, programState);
return(newProgramState.PushValue(sv));
}
public static async Task <Document> RefactorAsync(
Document document,
ExpressionSyntax expression,
ITypeSymbol typeSymbol,
CancellationToken cancellationToken = default)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
TypeSyntax type = typeSymbol.ToMinimalTypeSyntax(semanticModel, expression.SpanStart, SymbolDisplayFormats.FullName_WithoutNullableReferenceTypeModifier);
DefaultExpressionSyntax defaultExpression = DefaultExpression(type).WithTriviaFrom(expression);
return(await document.ReplaceNodeAsync(expression, defaultExpression, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
ExpressionSyntax expression,
ITypeSymbol typeSymbol,
CancellationToken cancellationToken = default(CancellationToken))
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
TypeSyntax type = typeSymbol.ToMinimalTypeSyntax(semanticModel, expression.SpanStart);
DefaultExpressionSyntax defaultExpression = SyntaxFactory.DefaultExpression(type)
.WithTriviaFrom(expression);
return(await document.ReplaceNodeAsync(expression, defaultExpression, cancellationToken).ConfigureAwait(false));
}
public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
{
if (Options.UseDefaultLiteral)
{
Debug.Assert(node.IsParentKind(SyntaxKind.EqualsValueClause) &&
node.Parent.IsParentKind(SyntaxKind.Parameter), node.ToString());
if (node.IsParentKind(SyntaxKind.EqualsValueClause) &&
node.Parent.IsParentKind(SyntaxKind.Parameter))
{
return(CSharpFactory.DefaultLiteralExpression());
}
}
return(base.VisitDefaultExpression(node));
}
private static bool IsDefaultOfReferenceType(DefaultExpressionSyntax defaultExpression, SemanticModel semanticModel, CancellationToken cancellationToken)
{
TypeSyntax type = defaultExpression.Type;
if (type != null)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, cancellationToken);
if (typeSymbol?.IsErrorType() == false &&
typeSymbol.IsReferenceType)
{
return(true);
}
}
return(false);
}
public static async Task <Document> RefactorAsync(
Document document,
ExpressionSyntax expression,
ITypeSymbol typeSymbol,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
TypeSyntax type = CSharpFactory.Type(typeSymbol)
.WithSimplifierAnnotation();
DefaultExpressionSyntax defaultExpression = SyntaxFactory.DefaultExpression(type)
.WithTriviaFrom(expression);
SyntaxNode newRoot = root.ReplaceNode(expression, defaultExpression);
return(document.WithSyntaxRoot(newRoot));
}
private bool TryDefaultExpression(DefaultExpressionSyntax defaultExpression,
IDom newItem,
SemanticModel model,
ref object value,
ref LiteralKind literalKind,
ref string constantIdentifier)
{
if (defaultExpression == null)
{
return(false);
}
literalKind = LiteralKind.Default;
value = Corporation
.Create(defaultExpression.Type, newItem, model)
.FirstOrDefault()
as IReferencedType;
return(true);
}
public void VisitDefaultExpression(DefaultExpressionSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
ExpressionStart(node);
_writer.WriteKeyword(PrinterKeyword.Default);
_writer.WriteSyntax(Syntax.OpenParen);
node.Type.Accept(this);
_writer.WriteSyntax(Syntax.CloseParen);
ExpressionEnd(node);
}
public override void VisitDefaultExpression(DefaultExpressionSyntax node)
{
base.VisitDefaultExpression(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitDefaultExpression(DefaultExpressionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitDefaultExpression(node);
}
private IEnumerable<ITypeSymbol> InferTypeInDefaultExpression(DefaultExpressionSyntax defaultExpression)
{
return InferTypes(defaultExpression);
}
public static void Go(OutputWriter writer, DefaultExpressionSyntax node)
{
var type = TypeProcessor.GetTypeInfo(node.Type).Type;
writer.Write("__Default!("+TypeProcessor.ConvertType(type)+")");
}
public DefaultExpressionTranslation(DefaultExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Type = syntax.Type.Get<TypeTranslation>(this);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitDefaultExpression(DefaultExpressionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitDefaultExpression(node);
}
public override SyntaxNode VisitDefaultExpression(DefaultExpressionSyntax node)
{
//Note: because we can not predict what T is, unless there is constraint on T said it's class or struct.
this.AppendCompileIssue(node, IssueType.Warning, IssueId.DefaultKeyword);
_output.Write(node, "null");
return node;
}
private IEnumerable<TypeInferenceInfo> InferTypeInDefaultExpression(DefaultExpressionSyntax defaultExpression)
{
return InferTypes(defaultExpression);
}
