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; }