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