private static bool Analyze(
CSharpCompilation compilation,
MethodSymbol method,
BoundBlock block,
DiagnosticBag diagnostics)
{
var result = ControlFlowPass.Analyze(compilation, method, block, diagnostics);
DataFlowPass.Analyze(compilation, method, block, diagnostics);
return result;
}
//TODO: it might be nice to make this a static method on Compiler
private void CompileMethod(
MethodSymbol methodSymbol,
ref ProcessedFieldInitializers processedInitializers,
SynthesizedSubmissionFields previousSubmissionFields,
TypeCompilationState compilationState)
{
cancellationToken.ThrowIfCancellationRequested();
SourceMethodSymbol sourceMethod = methodSymbol as SourceMethodSymbol;
if (methodSymbol.IsAbstract)
{
if ((object)sourceMethod != null)
{
bool diagsWritten;
sourceMethod.SetDiagnostics(ImmutableArray <Diagnostic> .Empty, out diagsWritten);
if (diagsWritten && !methodSymbol.IsImplicitlyDeclared && compilation.EventQueue != null)
{
compilation.SymbolDeclaredEvent(methodSymbol);
}
}
return;
}
// get cached diagnostics if not building and we have 'em
bool calculateDiagnosticsOnly = moduleBeingBuilt == null;
if (calculateDiagnosticsOnly && ((object)sourceMethod != null))
{
var cachedDiagnostics = sourceMethod.Diagnostics;
if (!cachedDiagnostics.IsDefault)
{
this.diagnostics.AddRange(cachedDiagnostics);
return;
}
}
ConsList <Imports> oldDebugImports = compilationState.CurrentDebugImports;
// In order to avoid generating code for methods with errors, we create a diagnostic bag just for this method.
DiagnosticBag diagsForCurrentMethod = DiagnosticBag.GetInstance();
try
{
bool includeInitializersInBody;
BoundBlock body;
// if synthesized method returns its body in lowered form
if (methodSymbol.SynthesizesLoweredBoundBody)
{
if (moduleBeingBuilt != null)
{
methodSymbol.GenerateMethodBody(compilationState, diagsForCurrentMethod);
this.diagnostics.AddRange(diagsForCurrentMethod);
}
return;
}
//EDMAURER initializers that have been analyzed but not yet lowered.
BoundStatementList analyzedInitializers = null;
ConsList <Imports> debugImports;
if (methodSymbol.IsScriptConstructor)
{
// rewrite top-level statements and script variable declarations to a list of statements and assignments, respectively:
BoundStatementList initializerStatements = InitializerRewriter.Rewrite(processedInitializers.BoundInitializers, methodSymbol);
// the lowered script initializers should not be treated as initializers anymore but as a method body:
body = new BoundBlock(initializerStatements.Syntax, ImmutableArray <LocalSymbol> .Empty, initializerStatements.Statements)
{
WasCompilerGenerated = true
};
includeInitializersInBody = false;
debugImports = null;
}
else
{
// do not emit initializers if we are invoking another constructor of this class:
includeInitializersInBody = !processedInitializers.BoundInitializers.IsDefaultOrEmpty && !HasThisConstructorInitializer(methodSymbol);
// lower initializers just once. the lowered tree will be reused when emitting all constructors
// with field initializers. Once lowered, these initializers will be stashed in processedInitializers.LoweredInitializers
// (see later in this method). Don't bother lowering _now_ if this particular ctor won't have the initializers
// appended to its body.
if (includeInitializersInBody && processedInitializers.LoweredInitializers == null)
{
analyzedInitializers = InitializerRewriter.Rewrite(processedInitializers.BoundInitializers, methodSymbol);
processedInitializers.HasErrors = processedInitializers.HasErrors || analyzedInitializers.HasAnyErrors;
// These analyses check for diagnostics in lambdas.
// Control flow analysis and implicit return insertion are unnecessary.
DataFlowPass.Analyze(compilation, methodSymbol, analyzedInitializers, diagsForCurrentMethod, requireOutParamsAssigned: false);
DiagnosticsPass.IssueDiagnostics(compilation, analyzedInitializers, diagsForCurrentMethod, methodSymbol);
}
body = Compiler.BindMethodBody(methodSymbol, diagsForCurrentMethod, this.generateDebugInfo, out debugImports);
}
#if DEBUG
// If the method is a synthesized static or instance constructor, then debugImports will be null and we will use the value
// from the first field initializer.
if (this.generateDebugInfo)
{
if ((methodSymbol.MethodKind == MethodKind.Constructor || methodSymbol.MethodKind == MethodKind.StaticConstructor) && methodSymbol.IsImplicitlyDeclared)
{
// There was no body to bind, so we didn't get anything from Compiler.BindMethodBody.
Debug.Assert(debugImports == null);
// Either there were no field initializers or we grabbed debug imports from the first one.
Debug.Assert(processedInitializers.BoundInitializers.IsDefaultOrEmpty || processedInitializers.FirstDebugImports != null);
}
}
#endif
debugImports = debugImports ?? processedInitializers.FirstDebugImports;
// Associate these debug imports with all methods generated from this one.
compilationState.CurrentDebugImports = debugImports;
if (body != null && methodSymbol is SourceMethodSymbol)
{
// TODO: Do we need to issue warnings for non-SourceMethodSymbol methods, like synthesized ctors?
DiagnosticsPass.IssueDiagnostics(compilation, body, diagsForCurrentMethod, methodSymbol);
}
BoundBlock flowAnalyzedBody = null;
if (body != null)
{
flowAnalyzedBody = FlowAnalysisPass.Rewrite(methodSymbol, body, diagsForCurrentMethod);
}
bool hasErrors = hasDeclarationErrors || diagsForCurrentMethod.HasAnyErrors() || processedInitializers.HasErrors;
// Record whether or not the bound tree for the lowered method body (including any initializers) contained any
// errors (note: errors, not diagnostics).
SetGlobalErrorIfTrue(hasErrors);
bool diagsWritten = false;
var actualDiagnostics = diagsForCurrentMethod.ToReadOnly();
if (sourceMethod != null)
{
actualDiagnostics = sourceMethod.SetDiagnostics(actualDiagnostics, out diagsWritten);
}
if (diagsWritten && !methodSymbol.IsImplicitlyDeclared && compilation.EventQueue != null)
{
var lazySemanticModel = body == null ? null : new Lazy <SemanticModel>(() =>
{
var syntax = body.Syntax;
var semanticModel = (CSharpSemanticModel)compilation.GetSemanticModel(syntax.SyntaxTree);
var memberModel = semanticModel.GetMemberModel(syntax);
if (memberModel != null)
{
memberModel.AddBoundTreeForStandaloneSyntax(syntax, body);
}
return(semanticModel);
});
compilation.EventQueue.Enqueue(new CompilationEvent.SymbolDeclared(compilation, methodSymbol, lazySemanticModel));
}
// Don't lower if we're not emitting or if there were errors.
// Methods that had binding errors are considered too broken to be lowered reliably.
if (calculateDiagnosticsOnly || hasErrors)
{
this.diagnostics.AddRange(actualDiagnostics);
return;
}
// ############################
// LOWERING AND EMIT
// Any errors generated below here are considered Emit diagnostics
// and will not be reported to callers Compilation.GetDiagnostics()
BoundStatement loweredBody = (flowAnalyzedBody == null) ? null :
Compiler.LowerStatement(this.generateDebugInfo, methodSymbol, flowAnalyzedBody, previousSubmissionFields, compilationState, diagsForCurrentMethod);
bool hasBody = loweredBody != null;
hasErrors = hasErrors || (hasBody && loweredBody.HasErrors) || diagsForCurrentMethod.HasAnyErrors();
SetGlobalErrorIfTrue(hasErrors);
// don't emit if the resulting method would contain initializers with errors
if (!hasErrors && (hasBody || includeInitializersInBody))
{
// Fields must be initialized before constructor initializer (which is the first statement of the analyzed body, if specified),
// so that the initialization occurs before any method overridden by the declaring class can be invoked from the base constructor
// and access the fields.
ImmutableArray <BoundStatement> boundStatements;
if (methodSymbol.IsScriptConstructor)
{
boundStatements = MethodBodySynthesizer.ConstructScriptConstructorBody(loweredBody, methodSymbol, previousSubmissionFields, compilation);
}
else
{
boundStatements = ImmutableArray <BoundStatement> .Empty;
if (analyzedInitializers != null)
{
processedInitializers.LoweredInitializers = (BoundStatementList)Compiler.LowerStatement(
this.generateDebugInfo,
methodSymbol,
analyzedInitializers,
previousSubmissionFields,
compilationState,
diagsForCurrentMethod);
Debug.Assert(!hasErrors);
hasErrors = processedInitializers.LoweredInitializers.HasAnyErrors || diagsForCurrentMethod.HasAnyErrors();
SetGlobalErrorIfTrue(hasErrors);
if (hasErrors)
{
this.diagnostics.AddRange(diagsForCurrentMethod);
return;
}
}
// initializers for global code have already been included in the body
if (includeInitializersInBody)
{
//TODO: rewrite any BoundThis and BoundBase nodes in the initializers to have the correct ThisParameter symbol
if (compilation.Options.Optimize)
{
// TODO: this part may conflict with InitializerRewriter.Rewrite in how it handles
// the first field initializer (see 'if (i == 0)'...) which seems suspicious
ArrayBuilder <BoundStatement> statements = ArrayBuilder <BoundStatement> .GetInstance();
statements.AddRange(boundStatements);
bool anyNonDefault = false;
foreach (var initializer in processedInitializers.LoweredInitializers.Statements)
{
if (ShouldOptimizeOutInitializer(initializer))
{
if (methodSymbol.IsStatic)
{
// NOTE: Dev11 removes static initializers if ONLY all of them are optimized out
statements.Add(initializer);
}
}
else
{
statements.Add(initializer);
anyNonDefault = true;
}
}
if (anyNonDefault)
{
boundStatements = statements.ToImmutableAndFree();
}
else
{
statements.Free();
}
}
else
{
boundStatements = boundStatements.Concat(processedInitializers.LoweredInitializers.Statements);
}
}
if (hasBody)
{
boundStatements = boundStatements.Concat(ImmutableArray.Create(loweredBody));
}
}
CSharpSyntaxNode syntax = methodSymbol.GetNonNullSyntaxNode();
var boundBody = BoundStatementList.Synthesized(syntax, boundStatements);
var emittedBody = Compiler.GenerateMethodBody(
compilationState,
methodSymbol,
boundBody,
diagsForCurrentMethod,
optimize,
debugDocumentProvider,
GetNamespaceScopes(methodSymbol, debugImports));
moduleBeingBuilt.SetMethodBody(methodSymbol, emittedBody);
}
this.diagnostics.AddRange(diagsForCurrentMethod);
}
finally
{
diagsForCurrentMethod.Free();
compilationState.CurrentDebugImports = oldDebugImports;
}
}