|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
namespace Microsoft.Interop
{
public sealed record SignatureContext
{
// We don't need the warnings around not setting the various
// non-nullable fields/properties on this type in the constructor
// since we always use a property initializer.
#pragma warning disable 8618
private SignatureContext()
{
}
#pragma warning restore
public ImmutableArray<TypePositionInfo> ElementTypeInformation { get; init; }
public IEnumerable<TypePositionInfo> ManagedParameters => ElementTypeInformation.Where(tpi => !TypePositionInfo.IsSpecialIndex(tpi.ManagedIndex));
public TypeSyntax StubReturnType { get; init; }
public IEnumerable<ParameterSyntax> StubParameters
{
get
{
foreach (TypePositionInfo typeInfo in ElementTypeInformation)
{
if (typeInfo.ManagedIndex != TypePositionInfo.UnsetIndex
&& typeInfo.ManagedIndex != TypePositionInfo.ReturnIndex)
{
yield return Parameter(Identifier(typeInfo.InstanceIdentifier))
.WithType(typeInfo.ManagedType.Syntax)
.WithModifiers(MarshallerHelpers.GetManagedParameterModifiers(typeInfo));
}
}
}
}
public ImmutableArray<AttributeListSyntax> AdditionalAttributes { get; init; }
public static SignatureContext Create(
IMethodSymbol method,
MarshallingInfoParser marshallingInfoParser,
StubEnvironment env,
CodeEmitOptions options,
Assembly generatorInfoAssembly)
{
ImmutableArray<TypePositionInfo> typeInfos = GenerateTypeInformation(method, marshallingInfoParser, env);
ImmutableArray<AttributeListSyntax>.Builder additionalAttrs = ImmutableArray.CreateBuilder<AttributeListSyntax>();
string generatorName = generatorInfoAssembly.GetName().Name;
string generatorVersion = generatorInfoAssembly.GetName().Version.ToString();
// Define additional attributes for the stub definition.
additionalAttrs.Add(
AttributeList(
SingletonSeparatedList(
Attribute(
NameSyntaxes.System_CodeDom_Compiler_GeneratedCodeAttribute,
AttributeArgumentList(
SeparatedList(
new[]
{
AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(generatorName))),
AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(generatorVersion)))
}))))));
if (options.SkipInit && !MethodIsSkipLocalsInit(env, method))
{
additionalAttrs.Add(
AttributeList(
SingletonSeparatedList(
// Adding the skip locals init indiscriminately since the source generator is
// targeted at non-blittable method signatures which typically will contain locals
// in the generated code.
Attribute(NameSyntaxes.System_Runtime_CompilerServices_SkipLocalsInitAttribute))));
}
return new SignatureContext()
{
StubReturnType = method.ReturnType.AsTypeSyntax(),
ElementTypeInformation = typeInfos,
AdditionalAttributes = additionalAttrs.ToImmutable(),
};
}
private static ImmutableArray<TypePositionInfo> GenerateTypeInformation(
IMethodSymbol method,
MarshallingInfoParser marshallingInfoParser,
StubEnvironment env)
{
// When the underlying method is a property accessor, bare attributes on the property declaration
// (e.g. `[MarshalUsing(typeof(X))] string Prop { get; set; }`) land on the property symbol and
// are not otherwise visible to the marshalling pipeline. Fall them through to the accessor's
// value surface only -- the getter's return, or the setter's value parameter (the last
// parameter, after any indexer index parameters). Index parameters on indexer accessors and the
// setter's `void` return are not value surfaces and do not inherit property-level attributes.
// Accessor-level attributes win over property-level ones on a per-type basis. Target-scoped
// attributes (`[return:]`, `[param:]`, `[get:]`, `[set:]`) are routed by Roslyn onto the
// accessor directly and so are already in the accessor's attribute set.
ImmutableArray<AttributeData> associatedPropertyAttributes = method.AssociatedSymbol is IPropertySymbol property
? property.GetAttributes()
: ImmutableArray<AttributeData>.Empty;
// The value parameter on a setter is the last parameter (index parameters precede it on
// indexer setters). Getters have no value parameter -- their value surface is the return.
int valueParameterIndex = method.MethodKind == MethodKind.PropertySet
? method.Parameters.Length - 1
: -1;
ImmutableArray<TypePositionInfo>.Builder typeInfos = ImmutableArray.CreateBuilder<TypePositionInfo>();
for (int i = 0; i < method.Parameters.Length; i++)
{
IParameterSymbol param = method.Parameters[i];
ImmutableArray<AttributeData> paramAttributes = i == valueParameterIndex
? MergeAccessorAndPropertyAttributes(param.GetAttributes(), associatedPropertyAttributes)
: param.GetAttributes();
MarshallingInfo marshallingInfo = marshallingInfoParser.ParseMarshallingInfo(param.Type, paramAttributes);
var typeInfo = TypePositionInfo.CreateForParameter(param, marshallingInfo, env.Compilation);
typeInfo = typeInfo with
{
ManagedIndex = i,
NativeIndex = typeInfos.Count
};
typeInfos.Add(typeInfo);
}
ImmutableArray<AttributeData> returnAttributes = method.MethodKind == MethodKind.PropertyGet
? MergeAccessorAndPropertyAttributes(method.GetReturnTypeAttributes(), associatedPropertyAttributes)
: method.GetReturnTypeAttributes();
TypePositionInfo retTypeInfo = new(ManagedTypeInfo.CreateTypeInfoForTypeSymbol(method.ReturnType), marshallingInfoParser.ParseMarshallingInfo(method.ReturnType, returnAttributes));
retTypeInfo = retTypeInfo with
{
ManagedIndex = TypePositionInfo.ReturnIndex,
NativeIndex = TypePositionInfo.ReturnIndex,
};
typeInfos.Add(retTypeInfo);
return typeInfos.ToImmutable();
}
private static ImmutableArray<AttributeData> MergeAccessorAndPropertyAttributes(
ImmutableArray<AttributeData> accessorAttributes,
ImmutableArray<AttributeData> associatedPropertyAttributes)
{
if (associatedPropertyAttributes.IsEmpty)
{
return accessorAttributes;
}
// Accessor-level attributes win over property-level ones at the same dedup key
// (attribute type + ElementIndirectionDepth for [MarshalUsing], attribute type alone
// otherwise). [MarshalUsing] is the only AllowMultiple = true attribute that flows
// through this merge: it can repeat on a single value surface with distinct
// ElementIndirectionDepth values to describe marshalling at successive levels of
// indirection (the value itself at depth 0, its elements at depth 1, and so on). The
// public contract on MarshalUsingAttribute.ElementIndirectionDepth states only one
// [MarshalUsing] with a given depth may be provided on a given parameter or return
// value, so dedup keys for [MarshalUsing] include the depth -- an accessor-level
// [MarshalUsing] overrides only the property-level [MarshalUsing] at the matching
// depth, and property-level [MarshalUsing]s at other depths flow through.
//
// To keep this dedup unambiguous, the COM generator additionally rejects accessor-level
// [MarshalUsing] attributes that omit the marshaller type (see
// MarshalUsingOnPropertyAccessorMustSpecifyType in GeneratorDiagnostics). That keeps the
// partial-split case (e.g., marshaller type on the property and count-only on the
// accessor) from silently dropping one side; the user combines the information on a
// single attribute or attaches the count-only [MarshalUsing] to the property.
HashSet<(string?, int)> accessorAttributeKeys = new();
foreach (AttributeData attr in accessorAttributes)
{
accessorAttributeKeys.Add(GetMergeKey(attr));
}
ImmutableArray<AttributeData>.Builder merged = ImmutableArray.CreateBuilder<AttributeData>(accessorAttributes.Length + associatedPropertyAttributes.Length);
merged.AddRange(accessorAttributes);
foreach (AttributeData attr in associatedPropertyAttributes)
{
if (!accessorAttributeKeys.Contains(GetMergeKey(attr)))
{
merged.Add(attr);
}
}
return merged.ToImmutable();
static (string?, int) GetMergeKey(AttributeData attr)
{
string? attributeName = attr.AttributeClass?.ToDisplayString();
int depth = 0;
if (attributeName == TypeNames.MarshalUsingAttribute)
{
foreach (KeyValuePair<string, TypedConstant> named in attr.NamedArguments)
{
if (named.Key == ManualTypeMarshallingHelper.MarshalUsingProperties.ElementIndirectionDepth)
{
depth = (int)named.Value.Value!;
break;
}
}
}
return (attributeName, depth);
}
}
public bool Equals(SignatureContext other)
{
// We don't check if the generator factories are equal since
// the generator factory is deterministically created based on the ElementTypeInformation and Options.
return other is not null
&& ElementTypeInformation.SequenceEqual(other.ElementTypeInformation)
&& StubReturnType.IsEquivalentTo(other.StubReturnType)
&& AdditionalAttributes.SequenceEqual(other.AdditionalAttributes, (IEqualityComparer<AttributeListSyntax>)SyntaxEquivalentComparer.Instance);
}
public override int GetHashCode()
{
throw new UnreachableException();
}
private static bool MethodIsSkipLocalsInit(StubEnvironment env, IMethodSymbol method)
{
if (env.EnvironmentFlags.HasFlag(EnvironmentFlags.SkipLocalsInit))
{
return true;
}
if (method.GetAttributes().Any(IsSkipLocalsInitAttribute))
{
return true;
}
for (INamedTypeSymbol type = method.ContainingType; type is not null; type = type.ContainingType)
{
if (type.GetAttributes().Any(IsSkipLocalsInitAttribute))
{
return true;
}
}
// We check the module case earlier, so we don't need to do it here.
return false;
static bool IsSkipLocalsInitAttribute(AttributeData a)
=> a.AttributeClass?.ToDisplayString() == TypeNames.System_Runtime_CompilerServices_SkipLocalsInitAttribute;
}
}
}
|