public void TestLambdaMethods()
{
var sourceTemplate = @"
using System;
class C
{{
Func<int> {0}(int p)
{{
return () => p - 1;
}}
Func<int> {0}1(int p)
{{
return () => p + 1;
}}
}}
";
int padding = GeneratedNames.MakeLambdaMethodName("A", -1, 0, 0).Length - 1;
string longName = s_longSymbolName.Substring(padding);
var source = string.Format(sourceTemplate, longName);
var comp = CreateCompilationWithMscorlib(source);
comp.VerifyDiagnostics();
comp.VerifyEmitDiagnostics(
// (13,16): error CS7013: Name '<longName + 1>b__3' exceeds the maximum length allowed in metadata.
// return () => p + 1;
Diagnostic(ErrorCode.ERR_MetadataNameTooLong, "() => p + 1").WithArguments("<" + longName + "1>b__0").WithLocation(13, 16));
}
internal SynthesizedLambdaMethod(NamedTypeSymbol containingType, MethodSymbol topLevelMethod, BoundLambda node, bool isStatic, TypeCompilationState compilationState)
: base(containingType,
node.Symbol,
null,
node.SyntaxTree.GetReference(node.Body.Syntax),
node.Syntax.GetLocation(),
GeneratedNames.MakeLambdaMethodName(topLevelMethod.Name, compilationState.GenerateTempNumber()),
(containingType is LambdaFrame ? DeclarationModifiers.Internal : DeclarationModifiers.Private)
| (isStatic ? DeclarationModifiers.Static : 0)
| (node.Symbol.IsAsync ? DeclarationModifiers.Async : 0))
{
TypeMap typeMap;
ImmutableArray <TypeParameterSymbol> typeParameters;
LambdaFrame lambdaFrame;
if (!topLevelMethod.IsGenericMethod)
{
typeMap = TypeMap.Empty;
typeParameters = ImmutableArray <TypeParameterSymbol> .Empty;
}
else if ((object)(lambdaFrame = this.ContainingType as LambdaFrame) != null)
{
typeMap = lambdaFrame.TypeMap;
typeParameters = ImmutableArray <TypeParameterSymbol> .Empty;
}
else
{
typeMap = TypeMap.Empty.WithAlphaRename(topLevelMethod, this, out typeParameters);
}
AssignTypeMapAndTypeParameters(typeMap, typeParameters);
}
private static string MakeName(string topLevelMethodName, MethodDebugId topLevelMethodId, ClosureKind closureKind, int lambdaOrdinal)
{
// Lambda method name must contain the declaring method ordinal to be unique unless the method is emitted into a closure class exclusive to the declaring method.
// Lambdas that only close over "this" are emitted directly into the top-level method containing type.
// Lambdas that don't close over anything (static) are emitted into a shared closure singleton.
return(GeneratedNames.MakeLambdaMethodName(
topLevelMethodName,
(closureKind == ClosureKind.General) ? -1 : topLevelMethodId.Ordinal,
topLevelMethodId.Generation,
lambdaOrdinal));
}
private static string MakeName(VariableSlotAllocator slotAllocatorOpt, TypeCompilationState compilationState, ClosureKind closureKind, MethodSymbol topLevelMethod, int topLevelMethodOrdinal, int lambdaOrdinal)
{
// TODO: slotAllocatorOpt?.GetPrevious()
// Lambda method name must contain the declaring method ordinal to be unique unless the method is emitted into a closure class exclusive to the declaring method.
// Lambdas that only close over "this" are emitted directly into the top-level method containing type.
// Lambdas that don't close over anything (static) are emitted into a shared closure singleton.
return(GeneratedNames.MakeLambdaMethodName(
topLevelMethod.Name,
(closureKind == ClosureKind.General) ? -1 : topLevelMethodOrdinal,
compilationState.ModuleBuilderOpt.CurrentGenerationOrdinal,
lambdaOrdinal));
}