private LocalRewriter(
CSharpCompilation compilation,
MethodSymbol containingMethod,
int containingMethodOrdinal,
BoundStatement rootStatement,
NamedTypeSymbol?containingType,
SyntheticBoundNodeFactory factory,
SynthesizedSubmissionFields previousSubmissionFields,
bool allowOmissionOfConditionalCalls,
DiagnosticBag diagnostics,
Instrumenter instrumenter)
{
_compilation = compilation;
_factory = factory;
_factory.CurrentFunction = containingMethod;
Debug.Assert(TypeSymbol.Equals(factory.CurrentType, (containingType ?? containingMethod.ContainingType), TypeCompareKind.ConsiderEverything2));
_dynamicFactory = new LoweredDynamicOperationFactory(factory, containingMethodOrdinal);
_previousSubmissionFields = previousSubmissionFields;
_allowOmissionOfConditionalCalls = allowOmissionOfConditionalCalls;
_diagnostics = diagnostics;
Debug.Assert(instrumenter != null);
#if DEBUG
// Ensure that only expected kinds of instrumenters are in use
_ = RemoveDynamicAnalysisInjectors(instrumenter);
#endif
_instrumenter = instrumenter;
_rootStatement = rootStatement;
}
private DynamicAnalysisInjector(
MethodSymbol method,
BoundStatement methodBody,
SyntheticBoundNodeFactory methodBodyFactory,
MethodSymbol createPayloadForMethodsSpanningSingleFile,
MethodSymbol createPayloadForMethodsSpanningMultipleFiles,
DiagnosticBag diagnostics,
DebugDocumentProvider debugDocumentProvider,
Instrumenter previous) : base(previous)
{
_createPayloadForMethodsSpanningSingleFile = createPayloadForMethodsSpanningSingleFile;
_createPayloadForMethodsSpanningMultipleFiles = createPayloadForMethodsSpanningMultipleFiles;
_method = method;
_methodBody = methodBody;
_spansBuilder = ArrayBuilder <SourceSpan> .GetInstance();
TypeSymbol payloadElementType = methodBodyFactory.SpecialType(SpecialType.System_Boolean);
_payloadType = ArrayTypeSymbol.CreateCSharpArray(methodBodyFactory.Compilation.Assembly, payloadElementType);
_methodPayload = methodBodyFactory.SynthesizedLocal(_payloadType, kind: SynthesizedLocalKind.InstrumentationPayload, syntax: methodBody.Syntax);
_diagnostics = diagnostics;
_debugDocumentProvider = debugDocumentProvider;
_methodBodyFactory = methodBodyFactory;
// The first point indicates entry into the method and has the span of the method definition.
SyntaxNode syntax = MethodDeclarationIfAvailable(methodBody.Syntax);
if (!method.IsImplicitlyDeclared)
{
_methodEntryInstrumentation = AddAnalysisPoint(syntax, SkipAttributes(syntax), methodBodyFactory);
}
}
private LocalRewriter(
CSharpCompilation compilation,
MethodSymbol containingMethod,
int containingMethodOrdinal,
BoundStatement rootStatement,
NamedTypeSymbol containingType,
SyntheticBoundNodeFactory factory,
SynthesizedSubmissionFields previousSubmissionFields,
bool allowOmissionOfConditionalCalls,
DiagnosticBag diagnostics,
Instrumenter instrumenter)
{
_compilation = compilation;
_factory = factory;
_factory.CurrentMethod = containingMethod;
Debug.Assert(factory.CurrentType == (containingType ?? containingMethod.ContainingType));
_dynamicFactory = new LoweredDynamicOperationFactory(factory, containingMethodOrdinal);
_previousSubmissionFields = previousSubmissionFields;
_allowOmissionOfConditionalCalls = allowOmissionOfConditionalCalls;
_diagnostics = diagnostics;
Debug.Assert(instrumenter != null);
_instrumenter = instrumenter;
_rootStatement = rootStatement;
}
public static DynamicAnalysisInjector TryCreate(MethodSymbol method, BoundStatement methodBody, SyntheticBoundNodeFactory methodBodyFactory, DiagnosticBag diagnostics, DebugDocumentProvider debugDocumentProvider, Instrumenter previous)
{
// Do not instrument implicitly-declared methods, except for constructors.
// Instrument implicit constructors in order to instrument member initializers.
if (method.IsImplicitlyDeclared && !method.IsImplicitConstructor)
{
return null;
}
// Do not instrument methods marked with or in scope of ExcludeFromCodeCoverageAttribute.
if (IsExcludedFromCodeCoverage(method))
{
return null;
}
MethodSymbol createPayload = GetCreatePayload(methodBodyFactory.Compilation, methodBody.Syntax, diagnostics);
// Do not instrument any methods if CreatePayload is not present.
if ((object)createPayload == null)
{
return null;
}
// Do not instrument CreatePayload if it is part of the current compilation (which occurs only during testing).
// CreatePayload will fail at run time with an infinite recursion if it is instrumented.
if (method.Equals(createPayload))
{
return null;
}
return new DynamicAnalysisInjector(method, methodBody, methodBodyFactory, createPayload, diagnostics, debugDocumentProvider, previous);
}
private static Instrumenter RemoveDynamicAnalysisInjectors(Instrumenter instrumenter)
{
switch (instrumenter)
{
case DynamicAnalysisInjector {
Previous: var previous
} :
return(RemoveDynamicAnalysisInjectors(previous));
public static DynamicAnalysisInjector TryCreate(
MethodSymbol method,
BoundStatement methodBody,
SyntheticBoundNodeFactory methodBodyFactory,
DiagnosticBag diagnostics,
DebugDocumentProvider debugDocumentProvider,
Instrumenter previous)
{
// Do not instrument implicitly-declared methods, except for constructors.
// Instrument implicit constructors in order to instrument member initializers.
if (method.IsImplicitlyDeclared && !method.IsImplicitConstructor)
{
return(null);
}
// Do not instrument methods marked with or in scope of ExcludeFromCodeCoverageAttribute.
if (IsExcludedFromCodeCoverage(method))
{
return(null);
}
MethodSymbol createPayloadForMethodsSpanningSingleFile = GetCreatePayloadOverload(
methodBodyFactory.Compilation,
WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
methodBody.Syntax,
diagnostics);
MethodSymbol createPayloadForMethodsSpanningMultipleFiles = GetCreatePayloadOverload(
methodBodyFactory.Compilation,
WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles,
methodBody.Syntax,
diagnostics);
// Do not instrument any methods if CreatePayload is not present.
if ((object)createPayloadForMethodsSpanningSingleFile == null || (object)createPayloadForMethodsSpanningMultipleFiles == null)
{
return(null);
}
// Do not instrument CreatePayload if it is part of the current compilation (which occurs only during testing).
// CreatePayload will fail at run time with an infinite recursion if it is instrumented.
if (method.Equals(createPayloadForMethodsSpanningSingleFile) || method.Equals(createPayloadForMethodsSpanningMultipleFiles))
{
return(null);
}
return(new DynamicAnalysisInjector(
method,
methodBody,
methodBodyFactory,
createPayloadForMethodsSpanningSingleFile,
createPayloadForMethodsSpanningMultipleFiles,
diagnostics,
debugDocumentProvider,
previous));
}
public override BoundNode VisitLocalFunctionStatement(BoundLocalFunctionStatement node)
{
_sawLocalFunctions = true;
var localFunction = node.Symbol;
CheckRefReadOnlySymbols(localFunction);
var typeParameters = localFunction.TypeParameters;
if (typeParameters.Any(typeParameter => typeParameter.HasUnmanagedTypeConstraint))
{
_factory.CompilationState.ModuleBuilderOpt?.EnsureIsUnmanagedAttributeExists();
}
if (_factory.CompilationState.Compilation.ShouldEmitNullableAttributes(localFunction))
{
bool constraintsNeedNullableAttribute = typeParameters.Any(
typeParameter => ((SourceTypeParameterSymbolBase)typeParameter).ConstraintsNeedNullableAttribute());
bool returnTypeNeedsNullableAttribute = localFunction.ReturnTypeWithAnnotations.NeedsNullableAttribute();
bool parametersNeedNullableAttribute = localFunction.ParameterTypesWithAnnotations.Any(parameter => parameter.NeedsNullableAttribute());
if (constraintsNeedNullableAttribute || returnTypeNeedsNullableAttribute || parametersNeedNullableAttribute)
{
_factory.CompilationState.ModuleBuilderOpt?.EnsureNullableAttributeExists();
}
}
var oldContainingSymbol = _factory.CurrentFunction;
var oldInstrumenter = _instrumenter;
try
{
_factory.CurrentFunction = localFunction;
if (localFunction.IsDirectlyExcludedFromCodeCoverage)
{
_instrumenter = RemoveDynamicAnalysisInjectors(oldInstrumenter);
}
return(base.VisitLocalFunctionStatement(node));
}
finally
{
_factory.CurrentFunction = oldContainingSymbol;
_instrumenter = oldInstrumenter;
}
}
private DynamicAnalysisInjector(MethodSymbol method, BoundStatement methodBody, SyntheticBoundNodeFactory methodBodyFactory, MethodSymbol createPayload, DiagnosticBag diagnostics, DebugDocumentProvider debugDocumentProvider, Instrumenter previous)
: base(previous)
{
_createPayload = createPayload;
_method = method;
_methodBody = methodBody;
_spansBuilder = ArrayBuilder<SourceSpan>.GetInstance();
TypeSymbol payloadElementType = methodBodyFactory.SpecialType(SpecialType.System_Boolean);
_payloadType = ArrayTypeSymbol.CreateCSharpArray(methodBodyFactory.Compilation.Assembly, payloadElementType);
_methodPayload = methodBodyFactory.SynthesizedLocal(_payloadType, kind: SynthesizedLocalKind.InstrumentationPayload, syntax: methodBody.Syntax);
_diagnostics = diagnostics;
_debugDocumentProvider = debugDocumentProvider;
_methodHasExplicitBlock = MethodHasExplicitBlock(method);
_methodBodyFactory = methodBodyFactory;
// The first point indicates entry into the method and has the span of the method definition.
_methodEntryInstrumentation = AddAnalysisPoint(MethodDeclarationIfAvailable(methodBody.Syntax), methodBodyFactory);
}
public static DynamicAnalysisInjector TryCreate(MethodSymbol method, BoundStatement methodBody, SyntheticBoundNodeFactory methodBodyFactory, DiagnosticBag diagnostics, DebugDocumentProvider debugDocumentProvider, Instrumenter previous)
{
// Do not instrument implicitly-declared methods.
if (!method.IsImplicitlyDeclared)
{
MethodSymbol createPayload = GetCreatePayload(methodBodyFactory.Compilation, methodBody.Syntax, diagnostics);
// Do not instrument any methods if CreatePayload is not present.
// Do not instrument CreatePayload if it is part of the current compilation (which occurs only during testing).
// CreatePayload will fail at run time with an infinite recursion if it Is instrumented.
if ((object)createPayload != null && !method.Equals(createPayload))
{
return new DynamicAnalysisInjector(method, methodBody, methodBodyFactory, createPayload, diagnostics, debugDocumentProvider, previous);
}
}
return null;
}
public CompoundInstrumenter(Instrumenter previous)
{
Debug.Assert(previous != null);
Previous = previous;
}
public DebugInfoInjector(Instrumenter previous)
: base(previous)
{
}
public DebugInfoInjector(Instrumenter previous)
: base (previous)
{
}
public static DynamicAnalysisInjector TryCreate(MethodSymbol method, BoundStatement methodBody, SyntheticBoundNodeFactory methodBodyFactory, DiagnosticBag diagnostics, DebugDocumentProvider debugDocumentProvider, Instrumenter previous)
{
// Do not instrument implicitly-declared methods.
if (!method.IsImplicitlyDeclared)
{
MethodSymbol createPayload = GetCreatePayload(methodBodyFactory.Compilation, methodBody.Syntax, diagnostics);
// Do not instrument any methods if CreatePayload is not present.
// Do not instrument CreatePayload if it is part of the current compilation (which occurs only during testing).
// CreatePayload will fail at run time with an infinite recursion if it Is instrumented.
if ((object)createPayload != null && !method.Equals(createPayload))
{
return(new DynamicAnalysisInjector(method, methodBody, methodBodyFactory, createPayload, diagnostics, debugDocumentProvider, previous));
}
}
return(null);
}
public CompoundInstrumenter(Instrumenter previous)
{
Debug.Assert(previous != null);
Previous = previous;
}