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)
{
HandleEmbeddedStatement(node.Block, curNode);
CreateConnectedEndNode(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));
}
