public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver, Assembly functionAssembly)
{
EnsureAssemblyOption(false);
// Scrape the compiled assembly for entry points
IList <MethodReference <MethodInfo> > methods =
functionAssembly.GetTypes().SelectMany(t =>
t.GetMethods().Select(m =>
new MethodReference <MethodInfo>(m.Name, m.IsPublic, m))).ToList();
MethodInfo entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
// For F#, this currently creates a malformed signautre with fewer parameter symbols than parameter names.
// For validation we only need the parameter names. The implementation of DotNetFunctionSignature copes with the
// lists having different lengths.
var parameters = entryPointReference.GetParameters().Select(x => new FunctionParameter(x.Name, x.ParameterType.FullName, x.IsOptional, GetParameterRefKind(x)));
// For F#, we always set this to true for now.
bool hasLocalTypeReference = true;
var signature = new FunctionSignature(entryPointReference.DeclaringType.FullName, entryPointReference.Name,
parameters.ToImmutableArray(), entryPointReference.ReturnType.Name, hasLocalTypeReference);
return(signature);
}
private async Task <MethodInfo> CreateFunctionTarget(CancellationToken cancellationToken)
{
try
{
await VerifyPackageReferencesAsync();
ICompilation compilation = _compilationService.GetFunctionCompilation(Metadata);
FunctionSignature functionSignature = compilation.GetEntryPointSignature(_functionEntryPointResolver);
ImmutableArray <Diagnostic> bindingDiagnostics = ValidateFunctionBindingArguments(functionSignature, _triggerInputName, _inputBindings, _outputBindings, throwIfFailed: true);
TraceCompilationDiagnostics(bindingDiagnostics);
Assembly assembly = compilation.EmitAndLoad(cancellationToken);
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
// Get our function entry point
_functionSignature = functionSignature;
System.Reflection.TypeInfo scriptType = assembly.DefinedTypes
.FirstOrDefault(t => string.Compare(t.Name, functionSignature.ParentTypeName, StringComparison.Ordinal) == 0);
return(_functionEntryPointResolver.GetFunctionEntryPoint(scriptType.DeclaredMethods.ToList()));
}
catch (CompilationErrorException ex)
{
TraceOnPrimaryHost("Function compilation error", TraceLevel.Error);
TraceCompilationDiagnostics(ex.Diagnostics);
throw;
}
}
public static CSharpFunctionSignature FromCompilation(Compilation compilation, IFunctionEntryPointResolver entryPointResolver)
{
if (compilation == null)
{
throw new ArgumentNullException("compilation");
}
if (entryPointResolver == null)
{
throw new ArgumentNullException("entryPointResolver");
}
if (!compilation.SyntaxTrees.Any())
{
throw new ArgumentException("The provided compilation does not have a syntax tree.", "compilation");
}
var methods = compilation.ScriptClass
.GetMembers()
.OfType <IMethodSymbol>()
.Select(m => new MethodReference <IMethodSymbol>(m.Name, m.DeclaredAccessibility == Accessibility.Public, m));
IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
var signature = new CSharpFunctionSignature(entryPointReference.Parameters);
signature.HasLocalTypeReference = entryPointReference.Parameters.Any(p => IsOrUsesAssemblyType(p.Type, entryPointReference.ContainingAssembly));
return(signature);
}
private MethodInfo CreateFunctionTarget(CancellationToken cancellationToken)
{
// TODO:Get this from some context set in/by the host.
bool debug = true;
MemoryStream assemblyStream = null;
MemoryStream pdbStream = null;
try
{
Script <object> script = CreateScript();
Compilation compilation = GetScriptCompilation(script, debug);
CSharpFunctionSignature functionSignature = CSharpFunctionSignature.FromCompilation(compilation, _functionEntryPointResolver);
ValidateFunctionBindingArguments(functionSignature, throwIfFailed: true);
using (assemblyStream = new MemoryStream())
{
using (pdbStream = new MemoryStream())
{
var result = compilation.Emit(assemblyStream, pdbStream);
// Check if cancellation was requested while we were compiling,
// and if so quit here.
cancellationToken.ThrowIfCancellationRequested();
if (!result.Success)
{
throw new CompilationErrorException("Script compilation failed.", result.Diagnostics);
}
Assembly assembly = Assembly.Load(assemblyStream.GetBuffer(), pdbStream.GetBuffer());
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
// Get our function entry point
System.Reflection.TypeInfo scriptType = assembly.DefinedTypes.FirstOrDefault(t => string.Compare(t.Name, ScriptClassName, StringComparison.Ordinal) == 0);
_functionSignature = functionSignature;
return(_functionEntryPointResolver.GetFunctionEntryPoint(scriptType.DeclaredMethods.ToList()));
}
}
}
catch (CompilationErrorException ex)
{
TraceWriter.Error("Function compilation error");
TraceCompilationDiagnostics(ex.Diagnostics);
throw;
}
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
if (!_compilation.SyntaxTrees.Any())
{
throw new InvalidOperationException("The current compilation does not have a syntax tree.");
}
var methods = _compilation.ScriptClass
.GetMembers()
.OfType <IMethodSymbol>()
.Select(m => new MethodReference <IMethodSymbol>(m.Name, m.DeclaredAccessibility == Accessibility.Public, m));
IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
bool hasLocalTypeReferences = entryPointReference.Parameters.Any(p => IsOrUsesAssemblyType(p.Type, entryPointReference.ContainingAssembly));
return(new FunctionSignature(entryPointReference.ContainingType.Name, entryPointReference.Name, entryPointReference.Parameters, hasLocalTypeReferences));
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
if (!_compilation.SyntaxTrees.Any())
{
throw new InvalidOperationException("The current compilation does not have a syntax tree.");
}
var methods = _compilation.ScriptClass
.GetMembers()
.OfType <IMethodSymbol>()
.Select(m => new MethodReference <IMethodSymbol>(m.Name, m.DeclaredAccessibility == Accessibility.Public, m));
IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
bool hasLocalTypeReferences = HasLocalTypeReferences(entryPointReference);
var functionParameters = entryPointReference.Parameters.Select(p => new FunctionParameter(p.Name, GetFullTypeName(p.Type), p.IsOptional, p.RefKind));
return(new FunctionSignature(entryPointReference.ContainingType.Name, entryPointReference.Name,
ImmutableArray.CreateRange(functionParameters.ToArray()), GetFullTypeName(entryPointReference.ReturnType), hasLocalTypeReferences));
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
if (!_compilation.SyntaxTrees.Any())
{
throw new InvalidOperationException("The current compilation does not have a syntax tree.");
}
var methods = _compilation.ScriptClass
.GetMembers()
.OfType<IMethodSymbol>()
.Select(m => new MethodReference<IMethodSymbol>(m.Name, m.DeclaredAccessibility == Accessibility.Public, m));
IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
bool hasLocalTypeReferences = HasLocalTypeReferences(entryPointReference);
var functionParameters = entryPointReference.Parameters.Select(p => new FunctionParameter(p.Name, GetFullTypeName(p.Type), p.IsOptional, p.RefKind));
return new FunctionSignature(entryPointReference.ContainingType.Name, entryPointReference.Name,
ImmutableArray.CreateRange(functionParameters.ToArray()), GetFullTypeName(entryPointReference.ReturnType), hasLocalTypeReferences);
}
private MethodInfo CreateFunctionTarget(CancellationToken cancellationToken)
{
MemoryStream assemblyStream = null;
MemoryStream pdbStream = null;
try
{
ICompilation compilation = _compilationService.GetFunctionCompilation(Metadata);
FunctionSignature functionSignature = compilation.GetEntryPointSignature(_functionEntryPointResolver);
ImmutableArray <Diagnostic> bindingDiagnostics = ValidateFunctionBindingArguments(functionSignature, throwIfFailed: true);
TraceCompilationDiagnostics(bindingDiagnostics);
using (assemblyStream = new MemoryStream())
{
using (pdbStream = new MemoryStream())
{
compilation.Emit(assemblyStream, pdbStream, cancellationToken);
// Check if cancellation was requested while we were compiling,
// and if so quit here.
cancellationToken.ThrowIfCancellationRequested();
Assembly assembly = Assembly.Load(assemblyStream.GetBuffer(), pdbStream.GetBuffer());
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
// Get our function entry point
_functionSignature = functionSignature;
System.Reflection.TypeInfo scriptType = assembly.DefinedTypes
.FirstOrDefault(t => string.Compare(t.Name, functionSignature.ParentTypeName, StringComparison.Ordinal) == 0);
return(_functionEntryPointResolver.GetFunctionEntryPoint(scriptType.DeclaredMethods.ToList()));
}
}
}
catch (CompilationErrorException ex)
{
TraceWriter.Error("Function compilation error");
TraceCompilationDiagnostics(ex.Diagnostics);
throw;
}
}
private async Task <MethodInfo> CreateFunctionTarget(CancellationToken cancellationToken)
{
try
{
await VerifyPackageReferencesAsync();
string eventName = string.Format(MetricEventNames.FunctionCompileLatencyByLanguageFormat, _compilationService.Language);
using (_metricsLogger.LatencyEvent(eventName))
{
ICompilation compilation = _compilationService.GetFunctionCompilation(Metadata);
Assembly assembly = compilation.EmitAndLoad(cancellationToken);
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
FunctionSignature functionSignature = compilation.GetEntryPointSignature(_functionEntryPointResolver);
ImmutableArray <Diagnostic> bindingDiagnostics = ValidateFunctionBindingArguments(functionSignature, _triggerInputName, _inputBindings, _outputBindings, throwIfFailed: true);
TraceCompilationDiagnostics(bindingDiagnostics);
// Set our function entry point signature
_functionSignature = functionSignature;
System.Reflection.TypeInfo scriptType = assembly.DefinedTypes
.FirstOrDefault(t => string.Compare(t.Name, functionSignature.ParentTypeName, StringComparison.Ordinal) == 0);
return(_functionEntryPointResolver.GetFunctionEntryPoint(scriptType.DeclaredMethods.ToList()));
}
}
catch (CompilationErrorException exc)
{
ImmutableArray <Diagnostic> diagnostics = AddFunctionDiagnostics(exc.Diagnostics);
// Here we only need to trace to system logs
TraceCompilationDiagnostics(diagnostics, LogTargets.System);
throw new CompilationErrorException(exc.Message, diagnostics);
}
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
EnsureAssemblyOption();
// Scrape the compiled assembly for entry points
IList<MethodReference<MethodInfo>> methods =
_assemblyOption.Value.GetTypes().SelectMany(t =>
t.GetMethods().Select(m =>
new MethodReference<MethodInfo>(m.Name, m.IsPublic, m))).ToList();
MethodInfo entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
// For F#, this currently creates a malformed signautre with fewer parameter symbols than parameter names.
// For validation we only need the parameter names. The implementation of DotNetFunctionSignature copes with the
// lists having different lengths.
var parameters = entryPointReference.GetParameters().Select(x => new FunctionParameter(x.Name, x.ParameterType.FullName, x.IsOptional, GetParameterRefKind(x)));
// For F#, we always set this to true for now.
bool hasLocalTypeReference = true;
var signature = new FunctionSignature(entryPointReference.DeclaringType.Name, entryPointReference.Name,
parameters.ToImmutableArray(), entryPointReference.ReturnType.Name, hasLocalTypeReference);
return signature;
}
