private BoundStatement BindUnsafeStatement(UnsafeStatementSyntax node, DiagnosticBag diagnostics) { var unsafeBinder = this.GetBinder(node); if (!this.Compilation.Options.AllowUnsafe) { Error(diagnostics, ErrorCode.ERR_IllegalUnsafe, node.UnsafeKeyword); } else if (this.IsIndirectlyInIterator) // called *after* we know the binder map has been created. { // Spec 8.2: "An iterator block always defines a safe context, even when its declaration // is nested in an unsafe context." Error(diagnostics, ErrorCode.ERR_IllegalInnerUnsafe, node.UnsafeKeyword); } return unsafeBinder.BindBlock(node.Block, diagnostics); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { node.Block?.Accept(this); base.VisitUnsafeStatement(node); }
/// <summary> /// /// </summary> /// <param name="node"></param> /// <remarks> /// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the /// tree by visiting the node. /// </remarks> public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { this.VisitStatement(node); }
public override SyntaxNode VisitUnsafeStatement(UnsafeStatementSyntax node) { this.AppendCompileIssue(node, IssueType.Error, IssueId.UnsafeNotSupport); return node; }
private Block BuildUnsafeStatement(UnsafeStatementSyntax statement, Block currentBlock) { var unsafeStatement = BuildStatement(statement.Block, CreateBlock(currentBlock)); return(CreateJumpBlock(statement, unsafeStatement)); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { throw new NotSupportedException(); }
/// <inheritdoc/> public override SyntaxNode?VisitUnsafeStatement(UnsafeStatementSyntax node) { Context.ReportDiagnostic(UnsafeStatement, node); return(base.VisitUnsafeStatement(node)); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { LogUnsupportedSyntax(node); }
// // Summary: // Called when the visitor visits a UnsafeStatementSyntax node. public virtual void VisitUnsafeStatement(UnsafeStatementSyntax node);
public override SyntaxNode VisitUnsafeStatement(UnsafeStatementSyntax node) { node = (UnsafeStatementSyntax)base.VisitUnsafeStatement(node); Classes.Add(node); return(node); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { HandleEmbeddedStatement(node.Block, curNode); CreateConnectedEndNode(node); }
public TameUnsafeStatementSyntax(UnsafeStatementSyntax node) { Node = node; AddChildren(); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { LogicalLineCount++; base.VisitUnsafeStatement(node); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { Emit <UnsafeBlock, UnsafeStatementSyntax>(node); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { VisitBlockIfNotNull(node.Block); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { throw new NotSupportedException("We do not support translation of unsafe statements!"); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { throw new NotSupportedException("Unsafe statement is not supported"); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitUnsafeStatement(UnsafeStatementSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitUnsafeStatement(node); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { base.VisitUnsafeStatement(node); }
/// <inheritdoc/> public override SyntaxNode?VisitUnsafeStatement(UnsafeStatementSyntax node) { Diagnostics.Add(UnsafeStatement, node); return(base.VisitUnsafeStatement(node)); }
public static void Go(OutputWriter writer, UnsafeStatementSyntax checkedExpressionSyntax) { writer.WriteLine("//Unsafe"); Core.Write(writer, checkedExpressionSyntax.Block); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitUnsafeStatement(UnsafeStatementSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitUnsafeStatement(node); }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { base.VisitUnsafeStatement(node); _counter++; }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { if (!Settings.IsAnyCodeFixEnabled( CodeFixIdentifiers.WrapInUnsafeStatement, CodeFixIdentifiers.MakeContainingDeclarationUnsafe)) { return; } SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindNode(root, context.Span, out SyntaxNode node)) { return; } foreach (Diagnostic diagnostic in context.Diagnostics) { switch (diagnostic.Id) { case CompilerDiagnosticIdentifiers.PointersAndFixedSizeBuffersMayOnlyBeUsedInUnsafeContext: { bool fStatement = false; bool fMemberDeclaration = false; foreach (SyntaxNode ancestor in node.AncestorsAndSelf()) { if (fStatement && fMemberDeclaration) { break; } if (!fStatement && ancestor is StatementSyntax) { fStatement = true; if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.WrapInUnsafeStatement)) { continue; } var statement = (StatementSyntax)ancestor; if (statement.IsKind(SyntaxKind.Block) && statement.Parent is StatementSyntax) { statement = (StatementSyntax)statement.Parent; } if (statement.IsKind(SyntaxKind.UnsafeStatement)) { break; } CodeAction codeAction = CodeAction.Create( "Wrap in unsafe block", cancellationToken => { BlockSyntax block = (statement.IsKind(SyntaxKind.Block)) ? (BlockSyntax)statement : SyntaxFactory.Block(statement); UnsafeStatementSyntax unsafeStatement = SyntaxFactory.UnsafeStatement(block).WithFormatterAnnotation(); return(context.Document.ReplaceNodeAsync(statement, unsafeStatement, cancellationToken)); }, GetEquivalenceKey(diagnostic, CodeFixIdentifiers.WrapInUnsafeStatement)); context.RegisterCodeFix(codeAction, diagnostic); continue; } else if (!fMemberDeclaration && ancestor is MemberDeclarationSyntax) { fMemberDeclaration = true; if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingDeclarationUnsafe)) { continue; } if (!ancestor.Kind().SupportsModifiers()) { continue; } ModifiersCodeFixRegistrator.AddModifier( context, diagnostic, ancestor, SyntaxKind.UnsafeKeyword, title: "Make containing declaration unsafe", additionalKey: CodeFixIdentifiers.MakeContainingDeclarationUnsafe); } } break; } } } }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { MarkUnsafe(); bool isRedundant = unsafeStateStack.Peek().InUnsafeContext; unsafeStateStack.Push(new UnsafeState(true)); base.VisitUnsafeStatement(node); isRedundant |= !unsafeStateStack.Pop().UseUnsafeConstructs; if (isRedundant) { ctx.ReportDiagnostic(Diagnostic.Create( descriptor, node.UnsafeKeyword.GetLocation() )); } }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindNode(root, context.Span, out SyntaxNode node)) { return; } Document document = context.Document; foreach (Diagnostic diagnostic in context.Diagnostics) { switch (diagnostic.Id) { case CompilerDiagnosticIdentifiers.CS0214_PointersAndFixedSizeBuffersMayOnlyBeUsedInUnsafeContext: { if (IsEnabled(diagnostic.Id, CodeFixIdentifiers.UseExplicitTypeInsteadOfVar, document, root.SyntaxTree) && node is StackAllocArrayCreationExpressionSyntax stackAllocArrayCreation && node.IsParentKind(SyntaxKind.EqualsValueClause) && node.Parent.IsParentKind(SyntaxKind.VariableDeclarator) && node.Parent.Parent.Parent is VariableDeclarationSyntax variableDeclaration && variableDeclaration.Type.IsVar) { TypeSyntax type = stackAllocArrayCreation.Type; if (type is ArrayTypeSyntax arrayType) { type = arrayType.ElementType; } CodeAction spanCodeAction = CodeAction.Create( "Use Span<T>", ct => { TypeSyntax spanOfT = SyntaxFactory.ParseTypeName($"global::System.Span<{type}>") .WithSimplifierAnnotation(); return(document.ReplaceNodeAsync(variableDeclaration.Type, spanOfT, ct)); }, GetEquivalenceKey(diagnostic, CodeFixIdentifiers.UseExplicitTypeInsteadOfVar, "System_Span_T")); context.RegisterCodeFix(spanCodeAction, diagnostic); CodeAction readOnlySpanCodeAction = CodeAction.Create( "Use ReadOnlySpan<T>", ct => { TypeSyntax spanOfT = SyntaxFactory.ParseTypeName($"global::System.ReadOnlySpan<{type}>") .WithSimplifierAnnotation(); return(document.ReplaceNodeAsync(variableDeclaration.Type, spanOfT, ct)); }, GetEquivalenceKey(diagnostic, CodeFixIdentifiers.UseExplicitTypeInsteadOfVar, "System_ReadOnlySpan_T")); context.RegisterCodeFix(readOnlySpanCodeAction, diagnostic); } var fStatement = false; var fMemberDeclaration = false; foreach (SyntaxNode ancestor in node.AncestorsAndSelf()) { if (fStatement && fMemberDeclaration) { break; } if (!fStatement && ancestor is StatementSyntax) { fStatement = true; if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.WrapInUnsafeStatement, document, root.SyntaxTree)) { continue; } var statement = (StatementSyntax)ancestor; if (statement.IsKind(SyntaxKind.Block) && statement.Parent is StatementSyntax statement2) { statement = statement2; } if (statement.IsKind(SyntaxKind.UnsafeStatement)) { break; } CodeAction codeAction = CodeAction.Create( "Wrap in unsafe block", ct => { BlockSyntax block = (statement.IsKind(SyntaxKind.Block)) ? (BlockSyntax)statement : SyntaxFactory.Block(statement); UnsafeStatementSyntax unsafeStatement = SyntaxFactory.UnsafeStatement(block).WithFormatterAnnotation(); return(document.ReplaceNodeAsync(statement, unsafeStatement, ct)); }, GetEquivalenceKey(diagnostic, CodeFixIdentifiers.WrapInUnsafeStatement)); context.RegisterCodeFix(codeAction, diagnostic); } else if (!fMemberDeclaration && ancestor is MemberDeclarationSyntax) { fMemberDeclaration = true; if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeContainingDeclarationUnsafe, document, root.SyntaxTree)) { continue; } if (!CSharpFacts.CanHaveModifiers(ancestor.Kind())) { continue; } ModifiersCodeFixRegistrator.AddModifier( context, diagnostic, ancestor, SyntaxKind.UnsafeKeyword, title: "Make containing declaration unsafe", additionalKey: CodeFixIdentifiers.MakeContainingDeclarationUnsafe); } } break; } } } }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { var binder = _enclosing.WithAdditionalFlags(BinderFlags.UnsafeRegion); AddToMap(node, binder); Visit(node.Block, binder); // This will create the block binder for the block. }
public override void VisitUnsafeStatement(UnsafeStatementSyntax node) { this.Logic.Add(this.nodeFactory.CreateUnsafe(node)); }