/// <summary>
/// The flow analysis pass. This pass reports required diagnostics for unreachable
/// statements and uninitialized variables (through the call to FlowAnalysisWalker.Analyze),
/// and inserts a final return statement if the end of a void-returning method is reachable.
/// </summary>
/// <param name="method">the method to be analyzed</param>
/// <param name="block">the method's body</param>
/// <param name="diagnostics">the receiver of the reported diagnostics</param>
/// <param name="hasTrailingExpression">indicates whether this Script had a trailing expression</param>
/// <param name="originalBodyNested">the original method body is the last statement in the block</param>
/// <returns>the rewritten block for the method (with a return statement possibly inserted)</returns>
public static BoundBlock Rewrite(
MethodSymbol method,
BoundBlock block,
DiagnosticBag diagnostics,
bool hasTrailingExpression,
bool originalBodyNested)
{
#if DEBUG
// We should only see a trailingExpression if we're in a Script initializer.
Debug.Assert(!hasTrailingExpression || method.IsScriptInitializer);
var initialDiagnosticCount = diagnostics.ToReadOnly().Length;
#endif
var compilation = method.DeclaringCompilation;
if (method.ReturnsVoid || method.IsIterator || method.IsTaskReturningAsync(compilation))
{
// we don't analyze synthesized void methods.
if ((method.IsImplicitlyDeclared && !method.IsScriptInitializer) || Analyze(compilation, method, block, diagnostics))
{
block = AppendImplicitReturn(block, method, (CSharpSyntaxNode)(method as SourceMethodSymbol)?.BodySyntax, originalBodyNested);
}
}
else if (Analyze(compilation, method, block, diagnostics))
{
// If the method is a lambda expression being converted to a non-void delegate type
// and the end point is reachable then suppress the error here; a special error
// will be reported by the lambda binder.
Debug.Assert(method.MethodKind != MethodKind.AnonymousFunction);
// Add implicit "return default(T)" if this is a submission that does not have a trailing expression.
var submissionResultType = (method as SynthesizedInteractiveInitializerMethod)?.ResultType;
if (!hasTrailingExpression && ((object)submissionResultType != null))
{
Debug.Assert(submissionResultType.SpecialType != SpecialType.System_Void);
var trailingExpression = new BoundDefaultOperator(method.GetNonNullSyntaxNode(), submissionResultType);
var newStatements = block.Statements.Add(new BoundReturnStatement(trailingExpression.Syntax, RefKind.None, trailingExpression));
block = new BoundBlock(block.Syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray<LocalFunctionSymbol>.Empty, newStatements) { WasCompilerGenerated = true };
#if DEBUG
// It should not be necessary to repeat analysis after adding this node, because adding a trailing
// return in cases where one was missing should never produce different Diagnostics.
var flowAnalysisDiagnostics = DiagnosticBag.GetInstance();
Debug.Assert(!Analyze(compilation, method, block, flowAnalysisDiagnostics));
Debug.Assert(flowAnalysisDiagnostics.ToReadOnly().SequenceEqual(diagnostics.ToReadOnly().Skip(initialDiagnosticCount)));
flowAnalysisDiagnostics.Free();
#endif
}
// If there's more than one location, then the method is partial and we
// have already reported a non-void partial method error.
else if (method.Locations.Length == 1)
{
diagnostics.Add(ErrorCode.ERR_ReturnExpected, method.Locations[0], method);
}
}
return block;
}
private bool ImplicitReturnIsOkay(MethodSymbol method)
{
return method.ReturnsVoid || method.IsIterator || method.IsTaskReturningAsync(this.Compilation);
}
internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method, TypeMap typeMap, out AsyncMethodBuilderMemberCollection collection)
{
if (method.IsVoidReturningAsync())
{
return TryCreate(
F: F,
builderType: F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncVoidMethodBuilder),
resultType: F.SpecialType(SpecialType.System_Void),
setException: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetException,
setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetResult,
awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__AwaitOnCompleted,
awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__AwaitUnsafeOnCompleted,
start: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__Start_T,
setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetStateMachine,
task: null,
collection: out collection);
}
if (method.IsTaskReturningAsync(F.Compilation))
{
NamedTypeSymbol builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder);
PropertySymbol task;
if (!TryGetWellKnownPropertyAsMember(F, WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Task, builderType, out task))
{
collection = default(AsyncMethodBuilderMemberCollection);
return false;
}
return TryCreate(
F: F,
builderType: F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder),
resultType: F.SpecialType(SpecialType.System_Void),
setException: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetException,
setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetResult,
awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__AwaitOnCompleted,
awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__AwaitUnsafeOnCompleted,
start: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Start_T,
setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetStateMachine,
task: task,
collection: out collection);
}
if (method.IsGenericTaskReturningAsync(F.Compilation))
{
TypeSymbol resultType = method.ReturnType.GetMemberTypeArgumentsNoUseSiteDiagnostics().Single();
if (resultType.IsDynamic())
{
resultType = F.SpecialType(SpecialType.System_Object);
}
if (typeMap != null)
{
resultType = typeMap.SubstituteType(resultType).Type;
}
NamedTypeSymbol builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T).Construct(resultType);
PropertySymbol task;
if (!TryGetWellKnownPropertyAsMember(F, WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Task, builderType, out task))
{
collection = default(AsyncMethodBuilderMemberCollection);
return false;
}
return TryCreate(
F: F,
builderType: builderType,
resultType: resultType,
setException: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetException,
setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetResult,
awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__AwaitOnCompleted,
awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__AwaitUnsafeOnCompleted,
start: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Start_T,
setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetStateMachine,
task: task,
collection: out collection);
}
throw ExceptionUtilities.UnexpectedValue(method);
}