public override Symbol VisitArrayType(ArrayTypeSymbol symbol)
{
var translatedElementType = (TypeSymbol)this.Visit(symbol.ElementType.TypeSymbol);
var translatedModifiers = VisitCustomModifiers(symbol.ElementType.CustomModifiers);
return(ArrayTypeSymbol.CreateArray(symbol.BaseTypeNoUseSiteDiagnostics.ContainingAssembly, symbol.ElementType.WithTypeAndModifiers(translatedElementType, translatedModifiers)));
}
internal override TypeSymbol GetSZArrayTypeSymbol(PEModuleSymbol moduleSymbol, TypeSymbol elementType, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers)
{
if (elementType is UnsupportedMetadataTypeSymbol)
{
return(elementType);
}
return(ArrayTypeSymbol.CreateArray(moduleSymbol.ContainingAssembly, CreateType(elementType, customModifiers)));
}
public override Symbol VisitArrayType(ArrayTypeSymbol symbol)
{
var otherElementType = (TypeSymbol)this.Visit(symbol.ElementType.TypeSymbol);
if ((object)otherElementType == null)
{
// For a newly added type, there is no match in the previous generation, so it could be null.
return(null);
}
var otherModifiers = VisitCustomModifiers(symbol.ElementType.CustomModifiers);
return(ArrayTypeSymbol.CreateArray(_otherAssembly, symbol.ElementType.WithTypeAndModifiers(otherElementType, otherModifiers)));
}
internal SynthesizedAttributeData SynthesizeTupleNamesAttribute(TypeSymbol type)
{
Debug.Assert((object)type != null);
Debug.Assert(type.ContainsTuple());
var stringType = GetSpecialType(SpecialType.System_String);
Debug.Assert((object)stringType != null);
var names = TupleNamesEncoder.Encode(type, stringType);
Debug.Assert(!names.IsDefault, "should not need the attribute when no tuple names");
var stringArray = ArrayTypeSymbol.CreateArray(stringType.ContainingAssembly, TypeSymbolWithAnnotations.Create(stringType));
var args = ImmutableArray.Create(new TypedConstant(stringArray, names));
return(TrySynthesizeAttribute(WellKnownMember.System_Runtime_CompilerServices_TupleElementNamesAttribute__ctorTransformNames, args));
}
private static ImmutableArray <MethodSymbol> GetNullableAttributeConstructors(
CSharpCompilation compilation,
NamedTypeSymbol containingType,
DiagnosticBag diagnostics)
{
var byteType = TypeSymbolWithAnnotations.Create(compilation.GetSpecialType(SpecialType.System_UInt8));
Binder.ReportUseSiteDiagnostics(byteType.TypeSymbol, diagnostics, Location.None);
var byteArray = TypeSymbolWithAnnotations.Create(
ArrayTypeSymbol.CreateArray(
byteType.TypeSymbol.ContainingAssembly,
byteType));
return(ImmutableArray.Create <MethodSymbol>(
new SynthesizedEmbeddedAttributeConstructorSymbol(
containingType,
m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, byteType, 0, RefKind.None))),
new SynthesizedEmbeddedAttributeConstructorSymbol(
containingType,
m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, byteArray, 0, RefKind.None)))));
}
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.CreateArray(methodBodyFactory.Compilation.Assembly, TypeSymbolWithAnnotations.Create(payloadElementType));
_diagnostics = diagnostics;
_debugDocumentProvider = debugDocumentProvider;
_methodBodyFactory = methodBodyFactory;
// Set the factory context to generate nodes for the current method
var oldMethod = methodBodyFactory.CurrentFunction;
methodBodyFactory.CurrentFunction = method;
_methodPayload = methodBodyFactory.SynthesizedLocal(_payloadType, kind: SynthesizedLocalKind.InstrumentationPayload, syntax: methodBody.Syntax);
// 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);
}
// Restore context
methodBodyFactory.CurrentFunction = oldMethod;
}
public override BoundStatement CreateBlockPrologue(BoundBlock original, out LocalSymbol synthesizedLocal)
{
BoundStatement previousPrologue = base.CreateBlockPrologue(original, out synthesizedLocal);
if (_methodBody == original)
{
_dynamicAnalysisSpans = _spansBuilder.ToImmutableAndFree();
// In the future there will be multiple analysis kinds.
const int analysisKind = 0;
ArrayTypeSymbol modulePayloadType =
ArrayTypeSymbol.CreateArray(_methodBodyFactory.Compilation.Assembly, TypeSymbolWithAnnotations.Create(_payloadType));
// Synthesize the initialization of the instrumentation payload array, using concurrency-safe code:
//
// var payload = PID.PayloadRootField[methodIndex];
// if (payload == null)
// payload = Instrumentation.CreatePayload(mvid, methodIndex, fileIndexOrIndices, ref PID.PayloadRootField[methodIndex], payloadLength);
BoundStatement payloadInitialization =
_methodBodyFactory.Assignment(
_methodBodyFactory.Local(_methodPayload),
_methodBodyFactory.ArrayAccess(
_methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType),
_methodBodyFactory.MethodDefIndex(_method)));
BoundExpression mvid = _methodBodyFactory.ModuleVersionId();
BoundExpression methodToken = _methodBodyFactory.MethodDefIndex(_method);
BoundExpression payloadSlot =
_methodBodyFactory.ArrayAccess(
_methodBodyFactory.InstrumentationPayloadRoot(analysisKind, modulePayloadType),
_methodBodyFactory.MethodDefIndex(_method));
BoundStatement createPayloadCall =
GetCreatePayloadStatement(
_dynamicAnalysisSpans,
_methodBody.Syntax,
_methodPayload,
_createPayloadForMethodsSpanningSingleFile,
_createPayloadForMethodsSpanningMultipleFiles,
mvid,
methodToken,
payloadSlot,
_methodBodyFactory,
_debugDocumentProvider);
BoundExpression payloadNullTest =
_methodBodyFactory.Binary(
BinaryOperatorKind.ObjectEqual,
_methodBodyFactory.SpecialType(SpecialType.System_Boolean),
_methodBodyFactory.Local(_methodPayload),
_methodBodyFactory.Null(_payloadType));
BoundStatement payloadIf = _methodBodyFactory.If(payloadNullTest, createPayloadCall);
Debug.Assert(synthesizedLocal == null);
synthesizedLocal = _methodPayload;
ArrayBuilder <BoundStatement> prologueStatements = ArrayBuilder <BoundStatement> .GetInstance(previousPrologue == null? 3 : 4);
prologueStatements.Add(payloadInitialization);
prologueStatements.Add(payloadIf);
if (_methodEntryInstrumentation != null)
{
prologueStatements.Add(_methodEntryInstrumentation);
}
if (previousPrologue != null)
{
prologueStatements.Add(previousPrologue);
}
return(_methodBodyFactory.StatementList(prologueStatements.ToImmutableAndFree()));
}
return(previousPrologue);
}