public override LambdaExpression CompileExpression(ExpressionToCompile expressionToCompile)
{
var options = ScriptOptions.Default
.AddReferences(expressionToCompile.ReferencedAssemblies.GetMetadataReferences())
.AddImports(expressionToCompile.ImportedNamespaces);
options = AddOptions(options);
var untypedExpressionScript = VisualBasicScript.Create($"? {expressionToCompile.Code}", options);
var compilation = untypedExpressionScript.GetCompilation();
var syntaxTree = compilation.SyntaxTrees.First();
var identifiers = IdentifiersWalker.GetIdentifiers(compilation, syntaxTree);
var resolvedIdentifiers =
identifiers
.Select(name => (Name: name, Type: expressionToCompile.VariableTypeGetter(name)))
.Where(var => var.Type != null)
.ToArray();
const string Comma = ", ";
var names = string.Join(Comma, resolvedIdentifiers.Select(var => var.Name));
var types = string.Join(Comma,
resolvedIdentifiers
.Select(var => var.Type)
.Concat(new[] { expressionToCompile.LambdaReturnType })
.Select(VisualBasicObjectFormatter.FormatTypeName));
var finalCompilation = compilation.ReplaceSyntaxTree(syntaxTree, syntaxTree.WithChangedText(SourceText.From(
$"Public Shared Function CreateExpression() As Expression(Of Func(Of {types}))\nReturn Function({names}) ({expressionToCompile.Code})\nEnd Function")));
var results = ScriptingAheadOfTimeCompiler.BuildAssembly(finalCompilation);
if (results.HasErrors)
{
throw FxTrace.Exception.AsError(new SourceExpressionException(SR.CompilerErrorSpecificExpression(expressionToCompile.Code, results), results.CompilerMessages));
}
return((LambdaExpression)results.ResultType.GetMethod("CreateExpression").Invoke(null, null));
}
public void Evaluate_SimpleArithmeticOperation_ResultReturned()
{
const string code = "Return 1 + 1";
var result = VisualBasicScript.Evaluate <int>(code);
Assert.Equal(2, result);
}
public override LambdaExpression CompileExpression(ExpressionToCompile expressionToCompile)
{
var options = ScriptOptions.Default
.AddReferences(expressionToCompile.ReferencedAssemblies)
.AddImports(expressionToCompile.ImportedNamespaces);
var untypedExpressionScript = VisualBasicScript.Create($"? {expressionToCompile.ExpressionString}", options);
var identifiers = IdentifiersWalker.GetIdentifiers(untypedExpressionScript);
var resolvedIdentifiers =
identifiers
.Select(name => (Name: name, Type: expressionToCompile.VariableTypeGetter(name)))
.Where(var => var.Type != null)
.ToArray();
const string Comma = ", ";
var names = string.Join(Comma, resolvedIdentifiers.Select(var => var.Name));
var types = string.Join(Comma,
resolvedIdentifiers
.Select(var => var.Type)
.Concat(new[] { expressionToCompile.LambdaReturnType ?? typeof(object) })
.Select(VisualBasicObjectFormatter.FormatTypeName));
var typedExpressionScript =
VisualBasicScript
.Create($"Dim resultExpression As Expression(Of Func(Of {types})) = Function({names}) ({expressionToCompile.ExpressionString})", options)
.ContinueWith("? resultExpression", options);
try
{
return((LambdaExpression)typedExpressionScript.RunAsync().GetResult().ReturnValue);
}
catch (CompilationErrorException ex)
{
throw FxTrace.Exception.AsError(new SourceExpressionException(SR.CompilerErrorSpecificExpression(expressionToCompile.ExpressionString, ex.ToString())));
}
}
public void Evaluate_MultipleSimpleArithmeticOperation_ResultsReturned()
{
for (var i = 0; i < 250; i++)
{
var code = $"Return {i} + {i}";
var result = VisualBasicScript.Evaluate <int>(code);
Assert.Equal(i + i, result);
}
}
public LambdaExpression CompileExpression(string expressionString, Func <string, Type> getVariableType, ScriptOptions options, Type lambdaReturnType = null)
{
var untypedExpressionScript = VisualBasicScript.Create($"? {expressionString}", options);
var identifiers = IdentifiersWalker.GetIdentifiers(untypedExpressionScript);
var resolvedIdentifiers =
identifiers
.Select(name => (Name: name, Type: getVariableType(name)))
.Where(var => var.Type != null)
.ToArray();
const string Comma = ", ";
var names = string.Join(Comma, resolvedIdentifiers.Select(var => var.Name));
var types = string.Join(Comma,
resolvedIdentifiers
.Select(var => var.Type)
.Concat(new[] { lambdaReturnType ?? typeof(object) })
.Select(type => GetTypeName(type)));
var typedExpressionScript =
VisualBasicScript
.Create($"Dim resultExpression As Expression(Of Func(Of {types})) = Function({names}) ({expressionString})", options)
.ContinueWith("? resultExpression", options);
return((LambdaExpression)typedExpressionScript.RunAsync().GetAwaiter().GetResult().ReturnValue);
}
protected override Script <T> Create <T>(string code, ScriptOptions options, Type globalsType, InteractiveAssemblyLoader assemblyLoader) => VisualBasicScript.Create <T>(code, options, globalsType, assemblyLoader);
public void Evaluate_NullInput_ExceptionThrown()
{
var ex = Assert.Throws <ArgumentNullException>(() => VisualBasicScript.Evaluate <string>(null));
Assert.Equal("code", ex.ParamName);
}
protected override ScriptState GetScriptState(string code, object globals)
{
return(VisualBasicScript.Run(code, ScriptOptions, globals));
}
protected override Script <object> Create(string code, ScriptOptions options) => VisualBasicScript.Create(code, options);
protected override ScriptState ExecuteScript(string text, ScriptOptions options)
{
return(VisualBasicScript.Run(text, options, new FiddlerScriptGlobals()));
}
