Move all scripting tests to the new API and tweak the API to simplify some scenarios

src/Compilers/CSharp/Test/CommandLine/CSharpCommandLineTest.csproj

@@ -95,6 +95,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CommandLineDiagnosticFormatterTests.cs" />
+    <Compile Include="CommandLineScriptTests.cs" />
     <Compile Include="CommandLineTests.cs" />
     <Compile Include="CommandLineTestResources.Designer.cs">
       <AutoGen>True</AutoGen>

src/Compilers/CSharp/Test/CommandLine/CommandLineScriptTests.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests
+{
+    public class CommandLineScriptTests : CSharpTestBase
+    {
+        // Simulates a sensible override of object.Equals.
+        private class TestDocumentationProviderEquals : DocumentationProvider
+        {
+            protected internal override string GetDocumentationForSymbol(string documentationMemberID, CultureInfo preferredCulture, CancellationToken cancellationToken) => "";
+            public override bool Equals(object obj) => obj != null && this.GetType() == obj.GetType();
+            public override int GetHashCode() => GetType().GetHashCode();
+        }
+
+        // Simulates no override of object.Equals.
+        private class TestDocumentationProviderNoEquals : DocumentationProvider
+        {
+            protected internal override string GetDocumentationForSymbol(string documentationMemberID, CultureInfo preferredCulture, CancellationToken cancellationToken) => "";
+            public override bool Equals(object obj) => ReferenceEquals(this, obj);
+            public override int GetHashCode() => RuntimeHelpers.GetHashCode(this);
+        }
+
+        private class TestMetadataReferenceProvider : Microsoft.CodeAnalysis.MetadataFileReferenceProvider
+        {
+            public Func<DocumentationProvider> MakeDocumentationProvider;
+            private readonly Dictionary<string, AssemblyMetadata> _cache = new Dictionary<string, AssemblyMetadata>();
+
+            public override PortableExecutableReference GetReference(string fullPath, MetadataReferenceProperties properties = default(MetadataReferenceProperties))
+            {
+                AssemblyMetadata metadata;
+                if (_cache.TryGetValue(fullPath, out metadata))
+                {
+                    return metadata.GetReference(MakeDocumentationProvider());
+                }
+
+                _cache.Add(fullPath, metadata = AssemblyMetadata.CreateFromFile(fullPath));
+                return metadata.GetReference(MakeDocumentationProvider());
+            }
+        }
+
+        [WorkItem(546173)]
+        [Fact]
+        public void CompilationChain_SystemObject_OrderDependency1()
+        {
+            CompilationChain_SystemObject_NotEquals();
+            CompilationChain_SystemObject_Equals();
+        }
+
+        [WorkItem(546173)]
+        [Fact]
+        public void CompilationChain_SystemObject_OrderDependency2()
+        {
+            CompilationChain_SystemObject_Equals();
+            CompilationChain_SystemObject_NotEquals();
+        }
+
+        [WorkItem(545665)]
+        [Fact]
+        public void CompilationChain_SystemObject_NotEquals()
+        {
+            // As in VS/ETA, make a new list of references for each submission.
+
+            var options = new CSharpParseOptions(kind: SourceCodeKind.Interactive, documentationMode: DocumentationMode.None);
+            var provider = new TestMetadataReferenceProvider() { MakeDocumentationProvider = () => new TestDocumentationProviderNoEquals() };
+
+            var s1 = CSharpCompilation.CreateSubmission("s1.dll",
+                syntaxTree: SyntaxFactory.ParseSyntaxTree("struct S { }", options),
+                references: MakeReferencesViaCommandLine(provider),
+                returnType: typeof(object));
+
+            s1.VerifyDiagnostics();
+
+            var s2 = CSharpCompilation.CreateSubmission("s2.dll",
+                syntaxTree: SyntaxFactory.ParseSyntaxTree("System.Collections.IEnumerable Iterator() { yield return new S(); }", options),
+                previousSubmission: s1,
+                references: MakeReferencesViaCommandLine(provider),
+                returnType: typeof(object));
+
+            Assert.NotEqual(s1.GetSpecialType(SpecialType.System_Object), s2.GetSpecialType(SpecialType.System_Object));
+
+            s2.VerifyDiagnostics(
+                // (1,58): error CS0029: Cannot implicitly convert type 'S' to 'object'
+                // System.Collections.IEnumerable Iterator() { yield return new S(); }
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new S()").WithArguments("S", "object"));
+        }
+
+        [WorkItem(545665)]
+        [Fact]
+        public void CompilationChain_SystemObject_Equals()
+        {
+            // As in VS/ETA, make a new list of references for each submission.
+
+            var options = new CSharpParseOptions(kind: SourceCodeKind.Interactive, documentationMode: DocumentationMode.None);
+            var provider = new TestMetadataReferenceProvider() { MakeDocumentationProvider = () => new TestDocumentationProviderEquals() };
+
+            var s1 = CSharpCompilation.CreateSubmission("s1.dll",
+                syntaxTree: SyntaxFactory.ParseSyntaxTree("struct S { }", options),
+                references: MakeReferencesViaCommandLine(provider),
+                returnType: typeof(object));
+
+            s1.VerifyDiagnostics();
+
+            var s2 = CSharpCompilation.CreateSubmission("s2.dll",
+                syntaxTree: SyntaxFactory.ParseSyntaxTree("System.Collections.IEnumerable Iterator() { yield return new S(); }", options),
+                previousSubmission: s1,
+                references: MakeReferencesViaCommandLine(provider),
+                returnType: typeof(object));
+
+            s2.VerifyDiagnostics();
+
+            Assert.Equal(s1.GetSpecialType(SpecialType.System_Object), s2.GetSpecialType(SpecialType.System_Object));
+        }
+
+        /// <summary>
+        /// NOTE: We're going through the command line parser to mimic the approach of visual studio and the ETA.
+        /// Crucially, this CommandLineArguments will use the provided TestMetadataReferenceProvider to attach a fresh
+        /// DocumentationProvider to each reference.
+        /// </summary>
+        private static IEnumerable<MetadataReference> MakeReferencesViaCommandLine(TestMetadataReferenceProvider metadataReferenceProvider)
+        {
+            var commandLineArguments = CSharpCommandLineParser.Interactive.Parse(
+                new string[0],
+                Directory.GetDirectoryRoot("."), //NOTE: any absolute path will do - we're not going to use this.
+                RuntimeEnvironment.GetRuntimeDirectory());
+
+            return commandLineArguments.ResolveMetadataReferences(new AssemblyReferenceResolver(MetadataFileReferenceResolver.Default, metadataReferenceProvider));
+        }
+    }
+}

src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs

@@ -5436,7 +5436,7 @@ public static void Main()
         }
 
         [WorkItem(544926, "DevDiv")]
-        [ConditionalFact(typeof(WindowsOnly))]
+        [ConditionalFact(typeof(ClrOnlyFact))]
         public void ResponseFilesWithNoconfig_03()
         {
             string source = Temp.CreateFile("a.cs").WriteAllText(@"

src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj

@@ -162,7 +162,7 @@
     <Compile Include="Emit\OptionalArgumentsTests.cs" />
     <Compile Include="Emit\OutputStreams.cs" />
     <Compile Include="Emit\ResourceTests.cs" />
-    <Compile Include="Emit\ScriptTests.cs" />
+    <Compile Include="CodeGen\CodeGenScriptTests.cs" />
     <Compile Include="PDB\CheckSumTest.cs" />
     <Compile Include="PDB\PDBAsyncTests.cs" />
     <Compile Include="PDB\PDBConstantTests.cs" />

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenScriptTests.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Emit
+{
+    public class CodeGenScriptTests : CSharpTestBase
+    {
+        [Fact]
+        public void AnonymousTypes_TopLevelVar()
+        {
+            string test = @"
+using System;
+var o = new { a = 1 };
+Console.WriteLine(o.ToString());
+";
+            var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);
+
+            CompileAndVerify(
+                CSharpCompilation.Create(
+                    assemblyName: "Test",
+                    options: TestOptions.ReleaseExe.WithScriptClassName("Script"),
+                    references: new[] { MscorlibRef_v4_0_30316_17626, SystemCoreRef },
+                    syntaxTrees: new[] { tree }),
+                expectedOutput: "{ a = 1 }"
+            );
+        }
+
+        [Fact]
+        public void AnonymousTypes_TopLevel_Object()
+        {
+            string test = @"
+using System;
+object o = new { a = 1 };
+Console.WriteLine(o.ToString());
+";
+            var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);
+
+            CompileAndVerify(
+                CSharpCompilation.Create(
+                    assemblyName: "Test",
+                    options: TestOptions.ReleaseExe.WithScriptClassName("Script"),
+                    references: new[] { MscorlibRef_v4_0_30316_17626, SystemCoreRef },
+                    syntaxTrees: new[] { tree }),
+                expectedOutput: "{ a = 1 }"
+            );
+        }
+
+        [Fact]
+        public void AnonymousTypes_TopLevel_NoLocal()
+        {
+            string test = @"
+using System;
+Console.WriteLine(new { a = 1 }.ToString());
+";
+            var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);
+
+            CompileAndVerify(
+                CSharpCompilation.Create(
+                    assemblyName: "Test",
+                    options: TestOptions.ReleaseExe.WithScriptClassName("Script"),
+                    references: new[] { MscorlibRef_v4_0_30316_17626, SystemCoreRef },
+                    syntaxTrees: new[] { tree }),
+                expectedOutput: "{ a = 1 }"
+            );
+        }
+
+        [Fact]
+        public void AnonymousTypes_NestedClass_Method()
+        {
+            string test = @"
+using System;
+class CLS 
+{
+    public void M()
+    {
+        Console.WriteLine(new { a = 1 }.ToString());
+    }
+}
+
+new CLS().M();
+";
+            var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);
+
+            CompileAndVerify(
+                CSharpCompilation.Create(
+                    assemblyName: "Test",
+                    options: TestOptions.ReleaseExe.WithScriptClassName("Script"),
+                    references: new[] { MscorlibRef_v4_0_30316_17626, SystemCoreRef },
+                    syntaxTrees: new[] { tree }),
+                expectedOutput: "{ a = 1 }"
+            );
+        }
+
+        [Fact]
+        public void AnonymousTypes_NestedClass_MethodParamDefValue()
+        {
+            string test = @"
+using System;
+class CLS 
+{
+    public void M(object p = new { a = 1 })
+    {
+        Console.WriteLine(""OK"");
+    }
+}
+new CLS().M();
+";
+            var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);
+
+            var compilation = CSharpCompilation.Create(
+                                assemblyName: "Test",
+                                options: TestOptions.ReleaseExe.WithScriptClassName("Script"),
+                                references: new[] { MscorlibRef },
+                                syntaxTrees: new[] { tree });
+
+            compilation.VerifyDiagnostics(
+                // (5,30): error CS1736: Default parameter value for 'p' must be a compile-time constant
+                //     public void M(object p = new { a = 1 })
+                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new { a = 1 }").WithArguments("p"));
+        }
+
+        [Fact]
+        public void AnonymousTypes_TopLevel_MethodParamDefValue()
+        {
+            string test = @"
+using System;
+
+public void M(object p = new { a = 1 })
+{
+    Console.WriteLine(""OK"");
+}
+
+M();
+";
+            var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);
+
+            var compilation = CSharpCompilation.Create(
+                                assemblyName: "Test",
+                                options: TestOptions.ReleaseExe.WithScriptClassName("Script"),
+                                references: new[] { MscorlibRef },
+                                syntaxTrees: new[] { tree });
+
+            compilation.VerifyDiagnostics(
+                // (4,26): error CS1736: Default parameter value for 'p' must be a compile-time constant
+                // public void M(object p = new { a = 1 })
+                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new { a = 1 }").WithArguments("p"));
+        }
+
+        [Fact]
+        public void AnonymousTypes_TopLevel_MethodAttribute()
+        {
+            string test = @"
+using System;
+
+class A: Attribute
+{
+    public object P;
+}
+
+[A(P = new { a = 1 })]
+public void M()
+{
+    Console.WriteLine(""OK"");
+}
+
+M();
+";
+            var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);
+
+            var compilation = CSharpCompilation.Create(
+                                assemblyName: "Test",
+                                options: TestOptions.ReleaseExe.WithScriptClassName("Script"),
+                                references: new[] { MscorlibRef },
+                                syntaxTrees: new[] { tree });
+
+            compilation.VerifyDiagnostics(
+                // (9,8): error CS0182: An attribute argument must be a constant expression, typeof expression or array creation expression of an attribute parameter type
+                // [A(P = new { a = 1 })]
+                Diagnostic(ErrorCode.ERR_BadAttributeArgument, "new { a = 1 }"));
+        }
+
+        [Fact]
+        public void AnonymousTypes_NestedTypeAttribute()
+        {
+            string test = @"
+using System;
+
+class A: Attribute
+{
+    public object P;
+}
+
+[A(P = new { a = 1 })]
+class CLS 
+{
+}
+";
+            var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);
+
+            var compilation = CSharpCompilation.Create(
+                                assemblyName: "Test",
+                                options: TestOptions.ReleaseExe.WithScriptClassName("Script"),
+                                references: new[] { MscorlibRef },
+                                syntaxTrees: new[] { tree });
+
+            compilation.VerifyDiagnostics(
+                // (9,8): error CS0836: Cannot use anonymous type in a constant expression
+                // [A(P = new { a = 1 })]
+                Diagnostic(ErrorCode.ERR_AnonymousTypeNotAvailable, "new"));
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void CompilationChain_AnonymousTypeTemplates()
+        {
+            var s0 = CreateSubmission("var x = new { a = 1 }; ");
+            var sx = CreateSubmission("var y = new { b = 2 }; ", previous: s0);
+            var s1 = CreateSubmission("var y = new { b = new { a = 3 } };", previous: s0);
+            var s2 = CreateSubmission("x = y.b; ", previous: s1);
+
+            s2.VerifyDiagnostics();
+            s2.EmitToArray();
+
+            Assert.True(s2.AnonymousTypeManager.AreTemplatesSealed);
+            Assert.Equal(0, s2.AnonymousTypeManager.GetAllCreatedTemplates().Length);
+
+            Assert.True(s1.AnonymousTypeManager.AreTemplatesSealed);
+            Assert.Equal(1, s1.AnonymousTypeManager.GetAllCreatedTemplates().Length);
+
+            Assert.True(s0.AnonymousTypeManager.AreTemplatesSealed);
+            Assert.Equal(1, s0.AnonymousTypeManager.GetAllCreatedTemplates().Length);
+
+            Assert.False(sx.AnonymousTypeManager.AreTemplatesSealed);
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void CompilationChain_DynamicSiteDelegates()
+        {
+            // TODO: references should be inherited
+            MetadataReference[] references = { SystemCoreRef, CSharpRef };
+
+            var s0 = CreateSubmission("var i = 1; dynamic d = null; d.m(ref i);", references);
+            var sx = CreateSubmission("var i = 1; dynamic d = null; d.m(ref i, ref i);", references, previous: s0);
+            var s1 = CreateSubmission("var i = 1; dynamic d = null; d.m(out i);", references, previous: s0);
+
+            s1.VerifyDiagnostics();
+            s1.EmitToArray();
+
+            // no new delegates should have been created:
+            Assert.True(s1.AnonymousTypeManager.AreTemplatesSealed);
+            Assert.Equal(0, s1.AnonymousTypeManager.GetAllCreatedTemplates().Length);
+
+            // delegate for (ref)
+            Assert.True(s0.AnonymousTypeManager.AreTemplatesSealed);
+            Assert.Equal(1, s0.AnonymousTypeManager.GetAllCreatedTemplates().Length);
+
+            Assert.False(sx.AnonymousTypeManager.AreTemplatesSealed);
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void Submissions_EmitToPeStream()
+        {
+            var s0 = CreateSubmission("int a = 1;");
+            var s11 = CreateSubmission("a + 1", previous: s0);
+            var s12 = CreateSubmission("a + 2", previous: s0);
+
+            s11.VerifyEmitDiagnostics();
+            s12.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void CrossSubmissionGenericInterfaceImplementation_Generic()
+        {
+            var c0 = CreateSubmission(@"
+public interface I<T>
+{
+    void m<TT>(T x, TT y);
+}
+");
+
+            var c1 = CreateSubmission(@"
+abstract public class C : I<int>
+{
+    public void m<TT>(int x, TT y)
+    {
+    }
+}", previous: c0);
+
+            c0.VerifyEmitDiagnostics();
+            c1.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void CrossSubmissionGenericInterfaceImplementation_Explicit_GenericMethod()
+        {
+            var c0 = CreateSubmission(@"
+public interface I<T>
+{
+    void m<S>(T x, S y);
+}
+");
+
+            var c1 = CreateSubmission(@"
+abstract public class C : I<int>
+{
+    void I<int>.m<S>(int x, S y)
+    {
+    }
+}", previous: c0);
+
+            c0.VerifyEmitDiagnostics();
+            c1.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void CrossSubmissionGenericInterfaceImplementation_Explicit()
+        {
+            var c0 = CreateSubmission(@"
+public interface I<T>
+{
+    void m(T x);
+}
+");
+
+            var c1 = CreateSubmission(@"
+abstract public class C : I<int>
+{
+    void I<int>.m(int x)
+    {
+    }
+}", previous: c0);
+
+            c0.VerifyEmitDiagnostics();
+            c1.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void CrossSubmissionGenericInterfaceImplementation_Explicit_NoGenericParametersInSignature()
+        {
+            var c0 = CreateSubmission(@"
+public interface I<T>
+{
+    void m(byte x);
+}
+");
+
+            var c1 = CreateSubmission(@"
+abstract public class C : I<int>
+{
+    void I<int>.m(byte x)
+    {
+    }
+}", previous: c0);
+
+            c0.VerifyEmitDiagnostics();
+            c1.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void GenericInterfaceImplementation_Explicit_NoGenericParametersInSignature()
+        {
+            var c0 = CreateSubmission(@"
+public interface I<T>
+{
+    void m(byte x);
+}
+abstract public class C : I<int>
+{
+    void I<int>.m(byte x)
+    {
+    }
+}");
+            c0.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void CrossSubmissionInterfaceImplementation_Explicit_NoGenericParametersInSignature()
+        {
+            var c0 = CreateSubmission(@"
+public interface I
+{
+    void m(byte x);
+}
+");
+
+            var c1 = CreateSubmission(@"
+abstract public class C : I
+{
+    void I.m(byte x)
+    {
+    }
+}", previous: c0);
+
+            c0.VerifyEmitDiagnostics();
+            c1.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void CrossSubmissionNestedGenericInterfaceImplementation_Explicit()
+        {
+            var c0 = CreateSubmission(@"
+class C<T>
+{
+    public interface I
+    {
+        void m(T x);
+    }
+}
+");
+
+            var c1 = CreateSubmission(@"
+abstract public class D : C<int>.I
+{
+    void C<int>.I.m(int x)
+    {
+    }
+}", previous: c0);
+
+            c0.VerifyEmitDiagnostics();
+            c1.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void NestedGenericInterfaceImplementation_Explicit()
+        {
+            var c0 = CreateSubmission(@"
+class C<T>
+{
+    public interface I
+    {
+        void m(T x);
+    }
+}
+abstract public class D : C<int>.I
+{
+    void C<int>.I.m(int x)
+    {
+    }
+}");
+            c0.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void ExternalInterfaceImplementation_Explicit()
+        {
+            var c0 = CreateSubmission(@"
+using System.Collections;
+using System.Collections.Generic;
+
+abstract public class C : IEnumerable<int>
+{
+    IEnumerator<int> IEnumerable<int>.GetEnumerator()
+    {
+        return null;
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return null;
+    }
+}");
+            c0.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void AbstractAccessors()
+        {
+            var c0 = CreateSubmission(@"
+public abstract class C
+{
+    public abstract event System.Action vEv;
+    public abstract int prop { get; set; }
+}
+");
+            c0.VerifyEmitDiagnostics();
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void ExprStmtWithMethodCall()
+        {
+            var s0 = CreateSubmission("int Foo() { return 2;}");
+            var s1 = CreateSubmission("(4 + 5) * Foo()", previous: s0);
+
+            s0.VerifyEmitDiagnostics();
+            s1.VerifyEmitDiagnostics();
+        }
+    }
+}

src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs

@@ -1925,5 +1925,82 @@ public void ConsistentParseOptions()
                 CSharpCompilation.Create(assemblyName, new[] { tree1, tree3 }, new[] { MscorlibRef }, compilationOptions);
             });
         }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void SubmissionCompilation_Errors()
+        {
+            var genericParameter = typeof(List<>).GetGenericArguments()[0];
+            var open = typeof(Dictionary<,>).MakeGenericType(typeof(int), genericParameter);
+            var ptr = typeof(int).MakePointerType();
+            var byref = typeof(int).MakeByRefType();
+
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", returnType: genericParameter));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", returnType: open));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", returnType: typeof(void)));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", returnType: byref));
+
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", hostObjectType: genericParameter));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", hostObjectType: open));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", hostObjectType: typeof(void)));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", hostObjectType: typeof(int)));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", hostObjectType: ptr));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", hostObjectType: byref));
+
+            var s0 = CSharpCompilation.CreateSubmission("a0", hostObjectType: typeof(List<int>));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a1", previousSubmission: s0, hostObjectType: typeof(List<bool>)));
+
+            // invalid options:
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseExe));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseDll.WithOutputKind(OutputKind.NetModule)));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseDll.WithOutputKind(OutputKind.WindowsRuntimeMetadata)));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseDll.WithOutputKind(OutputKind.WindowsRuntimeApplication)));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseDll.WithOutputKind(OutputKind.WindowsApplication)));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseDll.WithCryptoKeyContainer("foo")));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseDll.WithCryptoKeyFile("foo.snk")));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseDll.WithDelaySign(true)));
+            Assert.Throws<ArgumentException>(() => CSharpCompilation.CreateSubmission("a", options: TestOptions.ReleaseDll.WithDelaySign(false)));
+        }
+
+        private static void TestSubmissionResult(CSharpCompilation s, SpecialType? expectedType, bool expectedHasValue)
+        {
+            bool hasValue;
+            var type = s.GetSubmissionResultType(out hasValue);
+            Assert.Equal(expectedType, type != null ? type.SpecialType : (SpecialType?)null);
+            Assert.Equal(expectedHasValue, hasValue);
+        }
+
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void SubmissionResultType()
+        {
+            var submission = CSharpCompilation.CreateSubmission("sub");
+            bool hasValue;
+            Assert.Equal(SpecialType.System_Void, submission.GetSubmissionResultType(out hasValue).SpecialType);
+            Assert.False(hasValue);
+
+            TestSubmissionResult(CreateSubmission("1", parseOptions: TestOptions.Script), expectedType: SpecialType.System_Void, expectedHasValue: false);
+            TestSubmissionResult(CreateSubmission("1", parseOptions: TestOptions.Interactive), expectedType: SpecialType.System_Int32, expectedHasValue: true);
+            TestSubmissionResult(CreateSubmission("1;", parseOptions: TestOptions.Interactive), expectedType: SpecialType.System_Void, expectedHasValue: false);
+            TestSubmissionResult(CreateSubmission("void foo() { }", parseOptions: TestOptions.Interactive), expectedType: SpecialType.System_Void, expectedHasValue: false);
+            TestSubmissionResult(CreateSubmission("using System;", parseOptions: TestOptions.Interactive), expectedType: SpecialType.System_Void, expectedHasValue: false);
+            TestSubmissionResult(CreateSubmission("int i;", parseOptions: TestOptions.Interactive), expectedType: SpecialType.System_Void, expectedHasValue: false);
+            TestSubmissionResult(CreateSubmission("System.Console.WriteLine();", parseOptions: TestOptions.Interactive), expectedType: SpecialType.System_Void, expectedHasValue: false);
+            TestSubmissionResult(CreateSubmission("System.Console.WriteLine()", parseOptions: TestOptions.Interactive), expectedType: SpecialType.System_Void, expectedHasValue: true);
+            TestSubmissionResult(CreateSubmission("null", parseOptions: TestOptions.Interactive), expectedType: null, expectedHasValue: true);
+            TestSubmissionResult(CreateSubmission("System.Console.WriteLine", parseOptions: TestOptions.Interactive), expectedType: null, expectedHasValue: true);
+        }
+
+        /// <summary>
+        /// Previous submission has to have no errors.
+        /// </summary>
+        [ClrOnlyFact(ClrOnlyReason.Submission)]
+        public void PreviousSubmissionWithError()
+        {
+            var s0 = CreateSubmission("int a = \"x\";");
+            s0.VerifyDiagnostics(
+                // (1,9): error CS0029: Cannot implicitly convert type 'string' to 'int'
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, @"""x""").WithArguments("string", "int"));
+
+            Assert.Throws<InvalidOperationException>(() => CreateSubmission("a + 1", previous: s0));
+        }
     }
 }

src/Compilers/Test/Utilities/CSharp/CSharpCompilerTestUtilities.csproj

@@ -83,6 +83,7 @@
     <Compile Include="MetadataTestHelpers.cs" />
     <Compile Include="MockCSharpCompiler.cs" />
     <Compile Include="MockCsi.cs" />
+    <Compile Include="ScriptTestFixtures.cs" />
     <Compile Include="SemanticModelTestBase.cs" />
     <Compile Include="SymbolUtilities.cs" />
     <Compile Include="SyntaxTreeExtensions.cs" />

src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs

@@ -493,6 +493,25 @@ public static SyntaxTree ParseWithRoundTripCheck(string text, CSharpParseOptions
             return c;
         }
 
+        public static CSharpCompilation CreateSubmission(
+           string code,
+           IEnumerable<MetadataReference> references = null,
+           CSharpCompilationOptions options = null,
+           CSharpParseOptions parseOptions = null,
+           CSharpCompilation previous = null,
+           Type returnType = null,
+           Type hostObjectType = null)
+        {
+            return CSharpCompilation.CreateSubmission(
+                GetUniqueName(),
+                references: (references != null) ? new[] { MscorlibRef_v4_0_30316_17626 }.Concat(references) : new[] { MscorlibRef_v4_0_30316_17626 },
+                options: options,
+                syntaxTree: Parse(code, options: parseOptions ?? TestOptions.Interactive),
+                previousSubmission: previous,
+                returnType: returnType,
+                hostObjectType: hostObjectType);
+        }
+
         public CompilationVerifier CompileWithCustomILSource(string cSharpSource, string ilSource, Action<CSharpCompilation> compilationVerifier = null, bool importInternals = true, string expectedOutput = null)
         {
             var compilationOptions = (expectedOutput != null) ? TestOptions.ReleaseExe : TestOptions.ReleaseDll;

src/Compilers/Test/Utilities/CSharp/ScriptTestFixtures.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.CSharp.Test.Utilities
+{
+    public static class ScriptTestFixtures
+    {
+        internal static MetadataReference HostRef = MetadataReference.CreateFromAssemblyInternal(typeof(ScriptTestFixtures).GetTypeInfo().Assembly);
+
+        public class B
+        {
+            public int x = 1, w = 4;
+        }
+
+        public class C : B, I
+        {
+            public static readonly int StaticField = 123;
+            public int Y => 2;
+            public string N { get; set; } = "2";
+            public int Z() => 3;
+            public override int GetHashCode() => 123;
+        }
+
+        public interface I
+        {
+            string N { get; set; }
+            int Z();
+        }
+
+        private class PrivateClass : I
+        {
+            public string N { get; set; } = null;
+            public int Z() => 3;
+        }
+
+        public class B2
+        {
+            public int x = 1, w = 4;
+        }
+    }
+}

src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb

@@ -371,6 +371,23 @@ Public MustInherit Class BasicTestBaseBase
             options:=DirectCast(options, VisualBasicCompilationOptions))
     End Function
 
+    Public Shared Function CreateSubmission(code As String,
+                                            Optional references As IEnumerable(Of MetadataReference) = Nothing,
+                                            Optional options As VisualBasicCompilationOptions = Nothing,
+                                            Optional parseOptions As VisualBasicParseOptions = Nothing,
+                                            Optional previous As VisualBasicCompilation = Nothing,
+                                            Optional returnType As Type = Nothing,
+                                            Optional hostObjectType As Type = Nothing) As VisualBasicCompilation
+        Return VisualBasicCompilation.CreateSubmission(
+                GetUniqueName(),
+                references:=If(references Is Nothing, {MscorlibRef_v4_0_30316_17626, MsvbRef_v4_0_30319_17929}, {MscorlibRef_v4_0_30316_17626, MsvbRef_v4_0_30319_17929}.Concat(references)),
+                options:=options,
+                syntaxTree:=Parse(code, options:=If(parseOptions, TestOptions.Interactive)),
+                previousSubmission:=previous,
+                returnType:=returnType,
+                hostObjectType:=hostObjectType)
+    End Function
+
     Friend Shared Function GetAttributeNames(attributes As ImmutableArray(Of SynthesizedAttributeData)) As IEnumerable(Of String)
         Return attributes.Select(Function(a) a.AttributeClass.Name)
     End Function

src/Compilers/VisualBasic/Test/Emit/BasicCompilerEmitTest.vbproj

@@ -159,7 +159,7 @@
     <Compile Include="Emit\NoPiaEmbedTypes.vb" />
     <Compile Include="Emit\OptionalArgumentsTests.vb" />
     <Compile Include="Emit\ResourceTests.vb" />
-    <Compile Include="Emit\ScriptTests.vb" />
+    <Compile Include="CodeGen\CodeGenScriptTests.vb" />
     <Compile Include="ErrorHandling.vb" />
     <Compile Include="ExpressionTrees\CodeGenExprLambda.vb" />
     <Compile Include="ExpressionTrees\ExpTreeTestResources.Designer.vb" />

src/Compilers/VisualBasic/Test/Emit/Emit/ScriptTests.vb → src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenScriptTests.vb

@@ -8,7 +8,9 @@ Imports Roslyn.Test.Utilities
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Emit
 
-    Public Class ScriptTests
+    ' TODO (tomat): review tests
+
+    Public Class CodeGenScriptTests
         Inherits BasicTestBase
 
         <Fact>
@@ -221,60 +223,6 @@ Next
             Assert.False(s__.AnonymousTypeManager.AreTemplatesSealed)
         End Sub
 
-        Private Function CreateSubmission(code As String, options As VisualBasicParseOptions, Optional expectedErrorCount As Integer = 0) As VisualBasicCompilation
-            Dim submission = VisualBasicCompilation.CreateSubmission(
-                "sub",
-                references:={MetadataReference.CreateFromAssemblyInternal(GetType(Object).Assembly)},
-                syntaxTree:=Parse(code, options:=options))
-
-            Assert.Equal(expectedErrorCount, submission.GetDiagnostics(CompilationStage.Declare, True).Length())
-
-            Return submission
-        End Function
-
-        Private Shared Sub TestResult(s As VisualBasicCompilation, expectedType As SpecialType?, expectedHasValue As Boolean)
-            Dim hasValue As Boolean
-            Dim type = s.GetSubmissionResultType(hasValue)
-            Assert.Equal(expectedType, If(type IsNot Nothing, type.SpecialType, DirectCast(Nothing, SpecialType?)))
-            Assert.Equal(expectedHasValue, hasValue)
-        End Sub
-
-        Private Shared Sub TestResult(s As VisualBasicCompilation, expectedType As Func(Of TypeSymbol, Boolean), expectedHasValue As Boolean)
-            Dim hasValue As Boolean
-            Dim type = s.GetSubmissionResultType(hasValue)
-            Assert.True(expectedType(type), "unexpected type")
-            Assert.Equal(expectedHasValue, hasValue)
-        End Sub
-
-        <Fact>
-        Public Sub SubmissionResultType()
-            Dim submission = VisualBasicCompilation.CreateSubmission("sub")
-            Dim hasValue As Boolean
-            Assert.Equal(SpecialType.System_Void, submission.GetSubmissionResultType(hasValue).SpecialType)
-            Assert.False(hasValue)
-
-            TestResult(CreateSubmission("?1", TestOptions.Script, expectedErrorCount:=1), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
-            TestResult(CreateSubmission("?1", TestOptions.Interactive), expectedType:=SpecialType.System_Int32, expectedHasValue:=True)
-
-            ' TODO (tomat): optional ?
-            ' TestResult(CreateSubmission("1", OptionsInteractive), expectedType:=SpecialType.System_Int32, expectedHasValue:=True)
-
-            TestResult(CreateSubmission(<text>
-Sub Foo() 
-End Sub
-        </text>.Value, TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
-
-            TestResult(CreateSubmission("Imports System", TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
-            TestResult(CreateSubmission("Dim i As Integer", TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
-            TestResult(CreateSubmission("System.Console.WriteLine()", TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
-            TestResult(CreateSubmission("?System.Console.WriteLine()", TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=True)
-            TestResult(CreateSubmission("System.Console.ReadLine()", TestOptions.Interactive), expectedType:=SpecialType.System_String, expectedHasValue:=True)
-            TestResult(CreateSubmission("?System.Console.ReadLine()", TestOptions.Interactive), expectedType:=SpecialType.System_String, expectedHasValue:=True)
-            TestResult(CreateSubmission("?Nothing", TestOptions.Interactive), expectedType:=SpecialType.System_Object, expectedHasValue:=True)
-            TestResult(CreateSubmission("?AddressOf System.Console.WriteLine", TestOptions.Interactive), expectedType:=DirectCast(Nothing, SpecialType?), expectedHasValue:=True)
-            TestResult(CreateSubmission("?Function(x) x", TestOptions.Interactive), expectedType:=AddressOf IsDelegateType, expectedHasValue:=True)
-        End Sub
-
         ''' <summary>
         ''' LookupSymbols should not include the submission class.
         ''' </summary>
@@ -282,7 +230,11 @@ End Sub
         <Fact>
         Public Sub LookupSymbols()
             Dim text = "1 + "
-            Dim compilation = CreateSubmission(text, TestOptions.Interactive, expectedErrorCount:=1)
+            Dim compilation = CreateSubmission(text)
+
+            compilation.VerifyDiagnostics(
+                Diagnostic(ERRID.ERR_ObsoleteLineNumbersAreLabels, "1 "))
+
             Dim tree = compilation.SyntaxTrees.Single()
             Dim model = compilation.GetSemanticModel(tree)
             Dim symbols = model.LookupSymbols(text.Length)

src/Compilers/VisualBasic/Test/Semantic/BasicCompilerSemanticTest.vbproj

@@ -195,6 +195,7 @@
     <Compile Include="Semantics\QueryExpressions_LookupSymbols.vb" />
     <Compile Include="Semantics\QueryExpressions_SemanticModel.vb" />
     <Compile Include="Semantics\RedimStatementTests.vb" />
+    <Compile Include="Semantics\ScriptSemanticsTests.vb" />
     <Compile Include="Semantics\SelectCaseTests.vb" />
     <Compile Include="Semantics\SyncLockTests.vb" />
     <Compile Include="Semantics\SyntaxTreeRootTests.vb" />

src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb

@@ -1715,9 +1715,102 @@ End Namespace
             Dim tree3 = SyntaxFactory.ParseSyntaxTree("", VisualBasicParseOptions.Default.WithLanguageVersion(LanguageVersion.VisualBasic11))
 
             Dim assemblyName = GetUniqueName()
-            Dim CompilationOptions = New VisualBasic.VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
-            VisualBasic.VisualBasicCompilation.Create(assemblyName, {tree1, tree2}, {MscorlibRef}, CompilationOptions)
-            Assert.Throws(Of ArgumentException)(Function() VisualBasic.VisualBasicCompilation.Create(assemblyName, {tree1, tree3}, {MscorlibRef}, CompilationOptions))
+            Dim CompilationOptions = New VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+            VisualBasicCompilation.Create(assemblyName, {tree1, tree2}, {MscorlibRef}, CompilationOptions)
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.Create(assemblyName, {tree1, tree3}, {MscorlibRef}, CompilationOptions))
+        End Sub
+
+        <ClrOnlyFact(ClrOnlyReason.Submission)>
+        Public Sub SubmissionCompilation_Errors()
+            Dim genericParameter = GetType(List(Of)).GetGenericArguments()(0)
+            Dim open = GetType(Dictionary(Of,)).MakeGenericType(GetType(Integer), genericParameter)
+            Dim ptr = GetType(Integer).MakePointerType()
+            Dim byRefType = GetType(Integer).MakeByRefType()
+
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", returnType:=genericParameter))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", returnType:=open))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", returnType:=GetType(Void)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", returnType:=byRefType))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", hostObjectType:=genericParameter))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", hostObjectType:=open))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", hostObjectType:=GetType(Void)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", hostObjectType:=GetType(Integer)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", hostObjectType:=ptr))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", hostObjectType:=byRefType))
+
+            Dim s0 = VisualBasicCompilation.CreateSubmission("a0", hostObjectType:=GetType(List(Of Integer)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a1", previousSubmission:=s0, hostObjectType:=GetType(List(Of Boolean))))
+
+            ' invalid options
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseExe))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseDll.WithOutputKind(OutputKind.NetModule)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseDll.WithOutputKind(OutputKind.WindowsRuntimeMetadata)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseDll.WithOutputKind(OutputKind.WindowsRuntimeApplication)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseDll.WithOutputKind(OutputKind.WindowsApplication)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseDll.WithCryptoKeyContainer("foo")))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseDll.WithCryptoKeyFile("foo.snk")))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseDll.WithDelaySign(True)))
+            Assert.Throws(Of ArgumentException)(Function() VisualBasicCompilation.CreateSubmission("a", options:=TestOptions.ReleaseDll.WithDelaySign(False)))
+        End Sub
+
+        <ClrOnlyFact(ClrOnlyReason.Submission)>
+        Public Sub SubmissionResultType()
+            Dim submission = VisualBasicCompilation.CreateSubmission("sub")
+            Dim hasValue As Boolean
+            Assert.Equal(SpecialType.System_Void, submission.GetSubmissionResultType(hasValue).SpecialType)
+            Assert.False(hasValue)
+
+            TestSubmissionResult(CreateSubmission("?1", parseOptions:=TestOptions.Script), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
+            TestSubmissionResult(CreateSubmission("?1", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_Int32, expectedHasValue:=True)
+
+            TestSubmissionResult(CreateSubmission("1", parseOptions:=TestOptions.Script), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
+            ' TODO (https://github.com/dotnet/roslyn/issues/4763): '?' should be optional
+            ' TestSubmissionResult(CreateSubmission("1", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_Int32, expectedHasValue:=True)
+
+            ' TODO (https://github.com/dotnet/roslyn/issues/4766): ReturnType should not be ignored
+            ' TestSubmissionResult(CreateSubmission("?1", parseOptions:=TestOptions.Interactive, returnType:=GetType(Double)), expectedType:=SpecialType.System_Double, expectedHasValue:=True)
+
+            TestSubmissionResult(CreateSubmission("
+Sub Foo() 
+End Sub
+"), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
+
+            TestSubmissionResult(CreateSubmission("Imports System", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
+            TestSubmissionResult(CreateSubmission("Dim i As Integer", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
+            TestSubmissionResult(CreateSubmission("System.Console.WriteLine()", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=False)
+            TestSubmissionResult(CreateSubmission("?System.Console.WriteLine()", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_Void, expectedHasValue:=True)
+            TestSubmissionResult(CreateSubmission("System.Console.ReadLine()", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_String, expectedHasValue:=True)
+            TestSubmissionResult(CreateSubmission("?System.Console.ReadLine()", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_String, expectedHasValue:=True)
+            TestSubmissionResult(CreateSubmission("?Nothing", parseOptions:=TestOptions.Interactive), expectedType:=SpecialType.System_Object, expectedHasValue:=True)
+            TestSubmissionResult(CreateSubmission("?AddressOf System.Console.WriteLine", parseOptions:=TestOptions.Interactive), expectedType:=DirectCast(Nothing, SpecialType?), expectedHasValue:=True)
+            TestSubmissionResult(CreateSubmission("?Function(x) x", parseOptions:=TestOptions.Interactive), expectedType:=AddressOf IsDelegateType, expectedHasValue:=True)
+        End Sub
+
+        Private Shared Sub TestSubmissionResult(s As VisualBasicCompilation, expectedType As SpecialType?, expectedHasValue As Boolean)
+            Dim hasValue As Boolean
+            Dim type = s.GetSubmissionResultType(hasValue)
+            Assert.Equal(expectedType, If(type IsNot Nothing, type.SpecialType, DirectCast(Nothing, SpecialType?)))
+            Assert.Equal(expectedHasValue, hasValue)
+        End Sub
+
+        Private Shared Sub TestSubmissionResult(s As VisualBasicCompilation, expectedType As Func(Of TypeSymbol, Boolean), expectedHasValue As Boolean)
+            Dim hasValue As Boolean
+            Dim type = s.GetSubmissionResultType(hasValue)
+            Assert.True(expectedType(type), "unexpected type")
+            Assert.Equal(expectedHasValue, hasValue)
+        End Sub
+
+        ''' <summary>
+        ''' Previous submission has to have no errors.
+        ''' </summary>
+        <ClrOnlyFact(ClrOnlyReason.Submission)>
+        Public Sub PreviousSubmissionWithError()
+            Dim s0 = CreateSubmission("Dim a As X = 1")
+
+            s0.VerifyDiagnostics(
+                Diagnostic(ERRID.ERR_UndefinedType1, "X").WithArguments("X"))
+
+            Assert.Throws(Of InvalidOperationException)(Function() CreateSubmission("?a + 1", previous:=s0))
         End Sub
     End Class
 End Namespace

src/Compilers/VisualBasic/Test/Semantic/Semantics/ScriptSemanticsTests.vb

+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+Imports Roslyn.Test.Utilities
+
+Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
+    Public Class ScriptSemanticsTests
+        Inherits BasicTestBase
+
+        <WorkItem(530404)>
+        <Fact>
+        Public Sub DiagnosticsPass()
+            Dim source0 = "
+Function F(e As System.Linq.Expressions.Expression(Of System.Func(Of Object))) As Object
+    Return e.Compile()()
+End Function"
+
+            Dim c0 = CreateSubmission(source0, {SystemCoreRef})
+
+            Dim source1 = "
+F(Function()
+    Return Nothing
+  End Function)
+"
+            Dim c1 = CreateSubmission(source1, {SystemCoreRef}, previous:=c0)
+
+            AssertTheseDiagnostics(c1,
+<errors>
+BC36675: Statement lambdas cannot be converted to expression trees.
+F(Function()
+  ~~~~~~~~~~~
+</errors>)
+        End Sub
+    End Class
+End Namespace
+

src/Interactive/Features/Interactive/Core/InteractiveHost.Service.cs

@@ -424,7 +424,7 @@ private async Task<TaskResult> ExecuteAsync(Task<TaskResult> lastTask, RemoteAsy
                     {
                         var options = result.Options;
                         var state = result.State;
-                        script = Compile(state, text, null, ref options);
+                        script = Compile(state?.Script, text, null, ref options);
                         result = new TaskResult(options, state);
                     }
                     catch (CompilationErrorException e)
@@ -738,22 +738,19 @@ private AssemblyLoadResult LoadFromPathThrowing(string fullOriginalPath, bool ad
                 return result;
             }
 
-            private Script<object> Compile(ScriptState<object> previous, string text, string path, ref ScriptOptions options)
+            private Script<object> Compile(Script previousScript, string text, string path, ref ScriptOptions options)
             {
-                Script script = _repl.CreateScript(text).WithOptions(options);
+                Script script;
 
-                if (previous != null)
+                var scriptOptions = options.WithPath(path).WithIsInteractive(path == null);
+
+                if (previousScript != null)
                 {
-                    script = script.WithPrevious(previous.Script);
+                    script = previousScript.ContinueWith(text, scriptOptions);
                 }
                 else
                 {
-                    script = script.WithGlobalsType(_hostObject.GetType());
-                }
-
-                if (path != null)
-                {
-                    script = script.WithPath(path).WithOptions(script.Options.WithIsInteractive(false));
+                    script = _repl.CreateScript(text).WithOptions(scriptOptions).WithGlobalsType(_hostObject.GetType());
                 }
 
                 // force build so exception is thrown now if errors are found.
@@ -824,7 +821,7 @@ private async Task<ExecuteResult> ExecuteFileAsync(TaskResult result, string ful
                         {
                             var options = result.Options;
                             var state = result.State;
-                            script = Compile(state, content, fullPath, ref options);
+                            script = Compile(state?.Script, content, fullPath, ref options);
                             result = new TaskResult(options, state);
                         }
                         catch (CompilationErrorException e)
@@ -886,10 +883,14 @@ private async Task<ExecuteResult> ExecuteOnUIThread(TaskResult result, Script<ob
                         try
                         {
                             var state = result.State;
-                            var globals = state ?? (object)_hostObject;
-                            state = script.RunAsync(globals, CancellationToken.None);
-                            var value = await state.ReturnValue.ConfigureAwait(false);
-                            return new ExecuteResult(result.With(state), value, null, true);
+
+                            var task = (state == null) ?
+                                script.RunAsync(_hostObject, CancellationToken.None) :
+                                script.ContinueAsync(state, CancellationToken.None);
+
+                            state = await task.ConfigureAwait(false);
+
+                            return new ExecuteResult(result.With(state), state.ReturnValue, null, true);
                         }
                         catch (Exception e)
                         {

src/Scripting/CSharp/CSharpScript.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using System.Globalization;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CSharp;
 
 namespace Microsoft.CodeAnalysis.Scripting.CSharp
 {
@@ -18,10 +16,11 @@ public static class CSharpScript
         /// </summary>
         /// <param name="code">The source code of the script.</param>
         /// <param name="options">The script options.</param>
+        /// <param name="globalsType">Type of global object.</param>
         /// <typeparam name="T">The return type of the script</typeparam>
-        public static Script<T> Create<T>(string code, ScriptOptions options)
+        public static Script<T> Create<T>(string code, ScriptOptions options = null, Type globalsType = null)
         {
-            return new CSharpScript<T>(code, null, options, null, null, null);
+            return new Script<T>(CSharpScriptCompiler.Instance, code, options, globalsType, null, null);
         }
 
         /// <summary>
@@ -29,18 +28,10 @@ public static Script<T> Create<T>(string code, ScriptOptions options)
         /// </summary>
         /// <param name="code">The source code of the script.</param>
         /// <param name="options">The script options.</param>
-        public static Script<object> Create(string code, ScriptOptions options)
+        /// <param name="globalsType">Type of global object.</param>
+        public static Script<object> Create(string code, ScriptOptions options = null, Type globalsType = null)
         {
-            return Create<object>(code, options);
-        }
-
-        /// <summary>
-        /// Create a new C# script.
-        /// </summary>
-        /// <param name="code">The source code of the script.</param>
-        public static Script<object> Create(string code)
-        {
-            return Create<object>(code, null);
+            return Create<object>(code, options, globalsType);
         }
 
         /// <summary>
@@ -48,26 +39,13 @@ public static Script<object> Create(string code)
         /// </summary>
         /// <param name="code">The source code of the script.</param>
         /// <param name="options">The script options.</param>
-        /// <param name="globals">An object instance whose members can be accessed by the script as global variables, 
-        /// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
+        /// <param name="globals">An object instance whose members can be accessed by the script as global variables.</param>
+        /// <param name="globalsType">Type of global object, <paramref name="globals"/>.GetType() is used if not specified.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
         /// <typeparam name="T">The return type of the submission</typeparam>
-        public static ScriptState<T> RunAsync<T>(string code, ScriptOptions options, object globals, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return Create<T>(code, options).RunAsync(globals, cancellationToken);
-        }
-
-        /// <summary>
-        /// Run a C# script.
-        /// </summary>
-        /// <param name="code">The source code of the script.</param>
-        /// <param name="options">The script options.</param>
-        /// <param name="globals">An object instance whose members can be accessed by the script as global variables, 
-        /// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        public static ScriptState<object> RunAsync(string code, ScriptOptions options, object globals, CancellationToken cancellationToken = default(CancellationToken))
+        public static Task<ScriptState<T>> RunAsync<T>(string code, ScriptOptions options = null, object globals = null, Type globalsType = null, CancellationToken cancellationToken = default(CancellationToken))
         {
-            return RunAsync<object>(code, options, globals, cancellationToken);
+            return Create<T>(code, options, globalsType ?? globals?.GetType()).RunAsync(globals, cancellationToken);
         }
 
         /// <summary>
@@ -75,32 +53,12 @@ public static ScriptState<object> RunAsync(string code, ScriptOptions options, o
         /// </summary>
         /// <param name="code">The source code of the script.</param>
         /// <param name="options">The script options.</param>
+        /// <param name="globals">An object instance whose members can be accessed by the script as global variables.</param>
+        /// <param name="globalsType">Type of global object, <paramref name="globals"/>.GetType() is used if not specified.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
-        public static ScriptState<object> RunAsync(string code, ScriptOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return RunAsync<object>(code, options, null, cancellationToken);
-        }
-
-        /// <summary>
-        /// Run a C# script.
-        /// </summary>
-        /// <param name="code">The source code of the script.</param>
-        /// <param name="globals">An object instance whose members can be accessed by the script as global variables, 
-        /// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        public static ScriptState<object> RunAsync(string code, object globals, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return RunAsync<object>(code, null, globals, cancellationToken);
-        }
-
-        /// <summary>
-        /// Run a C# script.
-        /// </summary>
-        /// <param name="code">The source code of the script.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        public static ScriptState<object> RunAsync(string code, CancellationToken cancellationToken = default(CancellationToken))
+        public static Task<ScriptState<object>> RunAsync(string code, ScriptOptions options = null, object globals = null, Type globalsType = null, CancellationToken cancellationToken = default(CancellationToken))
         {
-            return RunAsync<object>(code, null, null, cancellationToken);
+            return RunAsync<object>(code, options, globals, globalsType, cancellationToken);
         }
 
         /// <summary>
@@ -108,28 +66,14 @@ public static ScriptState<object> RunAsync(string code, CancellationToken cancel
         /// </summary>
         /// <param name="code">The source code of the script.</param>
         /// <param name="options">The script options.</param>
-        /// <param name="globals">An object instance whose members can be accessed by the script as global variables, 
-        /// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
+        /// <param name="globals">An object instance whose members can be accessed by the script as global variables.</param>
+        /// <param name="globalsType">Type of global object, <paramref name="globals"/>.GetType() is used if not specified.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
         /// <typeparam name="T">The return type of the submission</typeparam>
         /// <return>Returns the value returned by running the script.</return>
-        public static Task<T> EvaluateAsync<T>(string code, ScriptOptions options, object globals, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return RunAsync<T>(code, options, globals, cancellationToken).ReturnValue;
-        }
-
-        /// <summary>
-        /// Run a C# script and return its resulting value.
-        /// </summary>
-        /// <param name="code">The source code of the script.</param>
-        /// <param name="options">The script options.</param>
-        /// <param name="globals">An object instance whose members can be accessed by the script as global variables, 
-        /// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        /// <return>Returns the value returned by running the script.</return>
-        public static Task<object> EvaluateAsync(string code, ScriptOptions options, object globals, CancellationToken cancellationToken = default(CancellationToken))
+        public static Task<T> EvaluateAsync<T>(string code, ScriptOptions options = null, object globals = null, Type globalsType = null, CancellationToken cancellationToken = default(CancellationToken))
         {
-            return EvaluateAsync<object>(code, options, globals, cancellationToken);
+            return RunAsync<T>(code, options, globals, globalsType, cancellationToken).GetEvaluationResultAsync();
         }
 
         /// <summary>
@@ -137,102 +81,14 @@ public static Task<object> EvaluateAsync(string code, ScriptOptions options, obj
         /// </summary>
         /// <param name="code">The source code of the script.</param>
         /// <param name="options">The script options.</param>
+        /// <param name="globals">An object instance whose members can be accessed by the script as global variables.</param>
+        /// <param name="globalsType">Type of global object, <paramref name="globals"/>.GetType() is used if not specified.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
         /// <return>Returns the value returned by running the script.</return>
-        public static Task<object> EvaluateAsync(string code, ScriptOptions options, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return EvaluateAsync<object>(code, options, null, cancellationToken);
-        }
-
-        /// <summary>
-        /// Run a C# script and return its resulting value.
-        /// </summary>
-        /// <param name="code">The source code of the script.</param>
-        /// <param name="globals">An object instance whose members can be accessed by the script as global variables, 
-        /// or a <see cref="ScriptState"/> instance that was the output from a previously run script.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        /// <return>Returns the value returned by running the script.</return>
-        public static Task<object> EvaluateAsync(string code, object globals, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return EvaluateAsync<object>(code, null, globals, cancellationToken);
-        }
-
-        /// <summary>
-        /// Run a C# script and return its resulting value.
-        /// </summary>
-        /// <param name="code">The source code of the script.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        /// <return>Returns the value returned by running the script.</return>
-        public static Task<object> EvaluateAsync(string code, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            return EvaluateAsync<object>(code, null, null, cancellationToken);
-        }
-    }
-
-    internal sealed class CSharpScript<T> : Script<T>
-    {
-        internal CSharpScript(string code, string path, ScriptOptions options, Type globalsType, ScriptBuilder builder, Script previous)
-            : base(code, path, options, globalsType, builder, previous)
-        {
-        }
-
-        internal override Script<T> Make(string code, string path, ScriptOptions options, Type globalsType, ScriptBuilder builder, Script previous)
-        {
-            return new CSharpScript<T>(code, path, options, globalsType, builder, previous);
-        }
-
-        #region Compilation
-        private static readonly CSharpParseOptions s_defaultInteractive = new CSharpParseOptions(languageVersion: LanguageVersion.CSharp6, kind: SourceCodeKind.Interactive);
-        private static readonly CSharpParseOptions s_defaultScript = new CSharpParseOptions(languageVersion: LanguageVersion.CSharp6, kind: SourceCodeKind.Script);
-
-        protected override Compilation CreateCompilation()
-        {
-            Compilation previousSubmission = null;
-            if (this.Previous != null)
-            {
-                previousSubmission = this.Previous.GetCompilation();
-            }
-
-            var references = this.GetReferencesForCompilation();
-
-            var parseOptions = this.Options.IsInteractive ? s_defaultInteractive : s_defaultScript;
-            var tree = SyntaxFactory.ParseSyntaxTree(this.Code, parseOptions, path: this.Path);
-
-            string assemblyName, submissionTypeName;
-            this.Builder.GenerateSubmissionId(out assemblyName, out submissionTypeName);
-
-            var compilation = CSharpCompilation.CreateSubmission(
-                assemblyName,
-                tree,
-                references,
-                new CSharpCompilationOptions(
-                    outputKind: OutputKind.DynamicallyLinkedLibrary,
-                    mainTypeName: null,
-                    scriptClassName: submissionTypeName,
-                    usings: this.Options.Namespaces,
-                    optimizationLevel: OptimizationLevel.Debug, // TODO
-                    checkOverflow: false,                  // TODO
-                    allowUnsafe: true,                     // TODO
-                    platform: Platform.AnyCpu,
-                    warningLevel: 4,
-                    xmlReferenceResolver: null, // don't support XML file references in interactive (permissions & doc comment includes)
-                    sourceReferenceResolver: SourceFileResolver.Default, // TODO
-                    metadataReferenceResolver: this.Options.ReferenceResolver,
-                    assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default
-                ),
-                previousSubmission,
-                this.ReturnType,
-                this.GlobalsType
-            );
-
-            return compilation;
-        }
-
-        protected override string FormatDiagnostic(Diagnostic diagnostic, CultureInfo culture)
+        public static Task<object> EvaluateAsync(string code, ScriptOptions options = null, object globals = null, Type globalsType = null, CancellationToken cancellationToken = default(CancellationToken))
         {
-            return CSharpDiagnosticFormatter.Instance.Format(diagnostic, culture);
+            return EvaluateAsync<object>(code, options, globals, globalsType, cancellationToken);
         }
-        #endregion
     }
 }
 

src/Scripting/CSharp/CSharpScriptCompiler.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Globalization;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Microsoft.CodeAnalysis.Scripting.CSharp
+{
+    internal sealed class CSharpScriptCompiler : ScriptCompiler
+    {
+        public static readonly ScriptCompiler Instance = new CSharpScriptCompiler();
+        private static readonly CSharpParseOptions s_defaultInteractive = new CSharpParseOptions(languageVersion: LanguageVersion.CSharp6, kind: SourceCodeKind.Interactive);
+        private static readonly CSharpParseOptions s_defaultScript = new CSharpParseOptions(languageVersion: LanguageVersion.CSharp6, kind: SourceCodeKind.Script);
+
+        private CSharpScriptCompiler()
+        {
+        }
+
+        public override DiagnosticFormatter DiagnosticFormatter => CSharpDiagnosticFormatter.Instance;
+
+        public override Compilation CreateSubmission(Script script)
+        {
+            Compilation previousSubmission = null;
+            if (script.Previous != null)
+            {
+                previousSubmission = script.Previous.GetCompilation();
+            }
+
+            var references = script.GetReferencesForCompilation();
+
+            var parseOptions = script.Options.IsInteractive ? s_defaultInteractive : s_defaultScript;
+            var tree = SyntaxFactory.ParseSyntaxTree(script.Code, parseOptions, script.Options.Path);
+
+            string assemblyName, submissionTypeName;
+            script.Builder.GenerateSubmissionId(out assemblyName, out submissionTypeName);
+
+            var compilation = CSharpCompilation.CreateSubmission(
+                assemblyName,
+                tree,
+                references,
+                new CSharpCompilationOptions(
+                    outputKind: OutputKind.DynamicallyLinkedLibrary,
+                    mainTypeName: null,
+                    scriptClassName: submissionTypeName,
+                    usings: script.Options.Namespaces,
+                    optimizationLevel: OptimizationLevel.Debug, // TODO
+                    checkOverflow: false,                  // TODO
+                    allowUnsafe: true,                     // TODO
+                    platform: Platform.AnyCpu,
+                    warningLevel: 4,
+                    xmlReferenceResolver: null, // don't support XML file references in interactive (permissions & doc comment includes)
+                    sourceReferenceResolver: SourceFileResolver.Default, // TODO
+                    metadataReferenceResolver: script.Options.ReferenceResolver,
+                    assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default
+                ),
+                previousSubmission,
+                script.ReturnType,
+                script.GlobalsType
+            );
+
+            return compilation;
+        }
+    }
+}

src/Scripting/CSharp/CSharpScripting.csproj

@@ -48,11 +48,12 @@
     <Reference Include="System.Reflection.Metadata, Version=$(SystemReflectionMetadataAssemblyVersion), Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\packages\System.Reflection.Metadata.$(SystemReflectionMetadataVersion)\lib\portable-net45+win8\System.Reflection.Metadata.dll</HintPath>
-    </Reference>  
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CSharpObjectFormatter.cs" />
     <Compile Include="CSharpScript.cs" />
+    <Compile Include="CSharpScriptCompiler.cs" />
     <Compile Include="CSharpScriptingResources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
@@ -75,6 +76,10 @@
   <ItemGroup>
     <None Include="project.json" />
   </ItemGroup>
+  <ItemGroup>
+    <PublicAPI Include="PublicAPI.Shipped.txt" />
+    <PublicAPI Include="PublicAPI.Unshipped.txt" />
+  </ItemGroup>
   <ImportGroup Label="Targets">
     <Import Project="..\..\..\build\Targets\VSL.Imports.targets" />
     <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />

src/Scripting/CSharp/PublicAPI.Unshipped.txt

+Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter
+Microsoft.CodeAnalysis.Scripting.CSharp.CSharpScript
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatArrayTypeName(System.Type arrayType, System.Array arrayOpt, Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions options) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatGeneratedTypeName(System.Type type) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(System.DateTime value) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(bool value) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(byte value, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(char c, bool quote, bool includeCodePoints = false, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(decimal value) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(double value) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(float value) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(int value, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(long value, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(sbyte value, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(short value, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(string value, bool quote, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(uint value, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(ulong value, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatLiteral(ushort value, bool useHexadecimalNumbers = false) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.FormatMemberName(System.Reflection.MemberInfo member) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.GenericParameterClosing.get -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.GenericParameterOpening.get -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.GetPrimitiveTypeName(Microsoft.CodeAnalysis.SpecialType type) -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.IsHiddenMember(System.Reflection.MemberInfo member) -> bool
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.NullLiteral.get -> string
+override Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.VoidDisplayString.get -> object
+static Microsoft.CodeAnalysis.Scripting.CSharp.CSharpScript.Create(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null, System.Type globalsType = null) -> Microsoft.CodeAnalysis.Scripting.Script<object>
+static Microsoft.CodeAnalysis.Scripting.CSharp.CSharpScript.Create<T>(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null, System.Type globalsType = null) -> Microsoft.CodeAnalysis.Scripting.Script<T>
+static Microsoft.CodeAnalysis.Scripting.CSharp.CSharpScript.EvaluateAsync(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null, object globals = null, System.Type globalsType = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<object>
+static Microsoft.CodeAnalysis.Scripting.CSharp.CSharpScript.EvaluateAsync<T>(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null, object globals = null, System.Type globalsType = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<T>
+static Microsoft.CodeAnalysis.Scripting.CSharp.CSharpScript.RunAsync(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null, object globals = null, System.Type globalsType = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Scripting.ScriptState<object>>
+static Microsoft.CodeAnalysis.Scripting.CSharp.CSharpScript.RunAsync<T>(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null, object globals = null, System.Type globalsType = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Scripting.ScriptState<T>>
+static readonly Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter.Instance -> Microsoft.CodeAnalysis.Scripting.CSharp.CSharpObjectFormatter
\ No newline at end of file

src/Scripting/CSharpTest/CSharpScriptEngine.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System;
-
-namespace Microsoft.CodeAnalysis.Scripting.CSharp
-{
-    /// <summary>
-    /// Represents a runtime execution context for C# scripts.
-    /// </summary>
-    internal sealed class CSharpScriptEngine : ScriptEngine
-    {
-        public CSharpScriptEngine(MetadataFileReferenceProvider metadataReferenceProvider = null)
-            : base(ScriptOptions.Default, metadataReferenceProvider)
-        {
-        }
-
-        internal override Script<T> Create<T>(string code, ScriptOptions options, Type globalsType)
-        {
-            return CSharpScript.Create<T>(code, options).WithGlobalsType(globalsType).WithBuilder(this.Builder);
-        }
-    }
-}

src/Scripting/CSharpTest/CSharpScriptingTest.csproj

@@ -66,7 +66,6 @@
     </Reference>  
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="CSharpScriptEngine.cs" />
     <Compile Include="InteractiveSessionFixtures.cs" />
     <Compile Include="InteractiveSessionTests.cs" />
     <Compile Include="ObjectFormatterTests.cs" />

src/Scripting/CSharpTest/ScriptTests.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using Microsoft.CodeAnalysis.Scripting;
-using Microsoft.CodeAnalysis.Scripting.CSharp;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
 
+#pragma warning disable RS0003 // Do not directly await a Task
+
 namespace Microsoft.CodeAnalysis.Scripting.CSharp.Test
 {
     public class ScriptTests : TestBase
@@ -21,12 +20,11 @@ public void TestCreateScript()
         }
 
         [Fact]
-        public void TestGetCompilation()
+        public async void TestGetCompilation()
         {
-            var script = CSharpScript.Create("1 + 2");
-            script.RunAsync(new ScriptTests());
-            var compilation = script.GetCompilation();
-            Assert.Equal(script.Code, compilation.SyntaxTrees.First().GetText().ToString());
+            var state = await CSharpScript.RunAsync("1 + 2", globals: new ScriptTests());
+            var compilation = state.Script.GetCompilation();
+            Assert.Equal(state.Script.Code, compilation.SyntaxTrees.First().GetText().ToString());
         }
 
         [Fact]
@@ -35,46 +33,58 @@ public void TestCreateScriptDelegate()
             // create a delegate for the entire script
             var script = CSharpScript.Create("1 + 2");
             var fn = script.CreateDelegate();
-            var value = fn();
-            Assert.Equal(3, value.Result);
+
+            Assert.Equal(3, fn().Result);
+            AssertEx.ThrowsArgumentException("globals", () => fn(new object()));
         }
 
         [Fact]
-        public void TestRunScript()
+        public void TestCreateScriptDelegateWithGlobals()
         {
-            var result = CSharpScript.RunAsync("1 + 2");
-            Assert.Equal(3, result.ReturnValue.Result);
+            // create a delegate for the entire script
+            var script = CSharpScript.Create<int>("X + Y", globalsType: typeof(Globals));
+            var fn = script.CreateDelegate();
+
+            AssertEx.ThrowsArgumentException("globals", () => fn());
+            AssertEx.ThrowsArgumentException("globals", () => fn(new object()));
+            Assert.Equal(4, fn(new Globals { X = 1, Y = 3 }).Result);
         }
 
         [Fact]
-        public void TestCreateAndRunScript()
+        public async void TestRunScript()
+        {
+            var state = await CSharpScript.RunAsync("1 + 2");
+            Assert.Equal(3, state.ReturnValue);
+        }
+
+        [Fact]
+        public async void TestCreateAndRunScript()
         {
             var script = CSharpScript.Create("1 + 2");
-            var result = script.RunAsync();
-            Assert.Same(script, result.Script);
-            Assert.Equal(3, result.ReturnValue.Result);
+            var state = await script.RunAsync();
+            Assert.Same(script, state.Script);
+            Assert.Equal(3, state.ReturnValue);
         }
 
         [Fact]
-        public void TestEvalScript()
+        public async void TestEvalScript()
         {
-            var value = CSharpScript.EvaluateAsync("1 + 2");
-            Assert.Equal(3, value.Result);
+            var value = await CSharpScript.EvaluateAsync("1 + 2");
+            Assert.Equal(3, value);
         }
 
         [Fact]
-        public void TestRunScriptWithSpecifiedReturnType()
+        public async void TestRunScriptWithSpecifiedReturnType()
         {
-            var result = CSharpScript.RunAsync("1 + 2");
-            Assert.Equal(3, result.ReturnValue.Result);
+            var state = await CSharpScript.RunAsync("1 + 2");
+            Assert.Equal(3, state.ReturnValue);
         }
 
         [Fact]
-        public void TestRunVoidScript()
+        public async void TestRunVoidScript()
         {
-            var result = CSharpScript.RunAsync("System.Console.WriteLine(0);");
-            var task = result.ReturnValue;
-            Assert.Null(task.Result);
+            var state = await CSharpScript.RunAsync("System.Console.WriteLine(0);");
+            Assert.Null(state.ReturnValue);
         }
 
         [Fact(Skip = "https://github.com/dotnet/roslyn/issues/170")]
@@ -114,44 +124,75 @@ public class Globals
         }
 
         [Fact]
-        public void TestRunScriptWithGlobals()
+        public async void TestRunScriptWithGlobals()
         {
-            var result = CSharpScript.RunAsync("X + Y", new Globals { X = 1, Y = 2 });
-            Assert.Equal(3, result.ReturnValue.Result);
+            var state = await CSharpScript.RunAsync("X + Y", globals: new Globals { X = 1, Y = 2 });
+            Assert.Equal(3, state.ReturnValue);
         }
 
         [Fact]
-        public void TestRunCreatedScriptWithExpectedGlobals()
+        public async void TestRunCreatedScriptWithExpectedGlobals()
         {
-            var script = CSharpScript.Create("X + Y").WithGlobalsType(typeof(Globals));
-            var result = script.RunAsync(new Globals { X = 1, Y = 2 });
-            Assert.Equal(3, result.ReturnValue.Result);
-            Assert.Same(script, result.Script);
+            var script = CSharpScript.Create("X + Y", globalsType: typeof(Globals));
+            var state = await script.RunAsync(new Globals { X = 1, Y = 2 });
+            Assert.Equal(3, state.ReturnValue);
+            Assert.Same(script, state.Script);
         }
 
         [Fact]
         public void TestRunCreatedScriptWithUnexpectedGlobals()
         {
             var script = CSharpScript.Create("X + Y");
-            var result = script.RunAsync(new Globals { X = 1, Y = 2 });
-            Assert.Equal(3, result.ReturnValue.Result);
 
-            // the end state of running the script should be based on a different script instance because of the globals
-            // not matching the original script definition.
-            Assert.NotSame(script, result.Script);
+            // Global variables passed to a script without a global type
+            AssertEx.ThrowsArgumentException("globals", () => script.RunAsync(new Globals { X = 1, Y = 2 }));
+        }
+
+        [Fact]
+        public void TestRunCreatedScriptWithoutGlobals()
+        {
+            var script = CSharpScript.Create("X + Y", globalsType: typeof(Globals));
+           
+            //  The script requires access to global variables but none were given
+            AssertEx.ThrowsArgumentException("globals", () => script.RunAsync());
+        }
+
+        [Fact]
+        public void TestRunCreatedScriptWithMismatchedGlobals()
+        {
+            var script = CSharpScript.Create("X + Y", globalsType: typeof(Globals));
+
+            //  The globals of type 'System.Object' is not assignable to 'Microsoft.CodeAnalysis.Scripting.CSharp.Test.ScriptTests+Globals'
+            AssertEx.ThrowsArgumentException("globals", () => script.RunAsync(new object()));
+        }
+
+        [Fact]
+        public async void ContinueAsync_Error1()
+        {
+            var state = await CSharpScript.RunAsync("X + Y", globals: new Globals());
+
+            AssertEx.ThrowsArgumentNull("previousState", () => state.Script.ContinueAsync(null));
+        }
+
+        [Fact]
+        public async void ContinueAsync_Error2()
+        {
+            var state1 = await CSharpScript.RunAsync("X + Y + 1", globals: new Globals());
+            var state2 = await CSharpScript.RunAsync("X + Y + 2", globals: new Globals());
+
+            AssertEx.ThrowsArgumentException("previousState", () => state1.Script.ContinueAsync(state2));
         }
 
         [Fact]
-        public void TestRunScriptWithScriptState()
+        public async void TestRunScriptWithScriptState()
         {
             // run a script using another scripts end state as the starting state (globals)
-            var result = CSharpScript.RunAsync("int X = 100;");
-            var result2 = CSharpScript.RunAsync("X + X", result);
-            Assert.Equal(200, result2.ReturnValue.Result);
+            var state = await CSharpScript.RunAsync("int X = 100;").ContinueWith("X + X");
+            Assert.Equal(200, state.ReturnValue);
         }
 
         [Fact]
-        public void TestRepl()
+        public async void TestRepl()
         {
             string[] submissions = new[]
             {
@@ -160,15 +201,13 @@ public void TestRepl()
                 "x + y"
             };
 
-            object input = null;
-            ScriptState<object> result = null;
+            var state = await CSharpScript.RunAsync("");
             foreach (var submission in submissions)
             {
-                result = CSharpScript.RunAsync(submission, input);
-                input = result;
+                state = await state.ContinueWithAsync(submission);
             }
 
-            Assert.Equal(10100, result.ReturnValue.Result);
+            Assert.Equal(10100, state.ReturnValue);
         }
 
 #if TODO // https://github.com/dotnet/roslyn/issues/3720
@@ -184,31 +223,31 @@ public void TestCreateMethodDelegate()
 #endif
 
         [Fact]
-        public void TestGetScriptVariableAfterRunningScript()
+        public async void TestGetScriptVariableAfterRunningScript()
         {
-            var result = CSharpScript.RunAsync("int x = 100;");
-            var globals = result.Variables.Names.ToList();
+            var state = await CSharpScript.RunAsync("int x = 100;");
+            var globals = state.Variables.Names.ToList();
             Assert.Equal(1, globals.Count);
             Assert.Equal(true, globals.Contains("x"));
-            Assert.Equal(true, result.Variables.ContainsVariable("x"));
-            Assert.Equal(100, (int)result.Variables["x"].Value);
+            Assert.Equal(true, state.Variables.ContainsVariable("x"));
+            Assert.Equal(100, (int)state.Variables["x"].Value);
         }
 
         [Fact]
-        public void TestBranchingSubscripts()
+        public async void TestBranchingSubscripts()
         {
             // run script to create declaration of M
-            var result1 = CSharpScript.RunAsync("int M(int x) { return x + x; }");
+            var state1 = await CSharpScript.RunAsync("int M(int x) { return x + x; }");
 
             // run second script starting from first script's end state
             // this script's new declaration should hide the old declaration
-            var result2 = CSharpScript.RunAsync("int M(int x) { return x * x; } M(5)", result1);
-            Assert.Equal(25, result2.ReturnValue.Result);
+            var state2 = await state1.ContinueWithAsync("int M(int x) { return x * x; } M(5)");
+            Assert.Equal(25, state2.ReturnValue);
 
             // run third script also starting from first script's end state
             // it should not see any declarations made by the second script.
-            var result3 = CSharpScript.RunAsync("M(5)", result1);
-            Assert.Equal(10, result3.ReturnValue.Result);
+            var state3 = await state1.ContinueWithAsync("M(5)");
+            Assert.Equal(10, state3.ReturnValue);
         }
     }
 }

src/Scripting/Core/PublicAPI.Unshipped.txt

+Microsoft.CodeAnalysis.MetadataShadowCopy
+Microsoft.CodeAnalysis.MetadataShadowCopy.DocumentationFile.get -> Microsoft.CodeAnalysis.ShadowCopy
+Microsoft.CodeAnalysis.MetadataShadowCopy.Metadata.get -> Microsoft.CodeAnalysis.Metadata
+Microsoft.CodeAnalysis.MetadataShadowCopy.PrimaryModule.get -> Microsoft.CodeAnalysis.ShadowCopy
+Microsoft.CodeAnalysis.Scripting.AssemblyLoadResult
+Microsoft.CodeAnalysis.Scripting.AssemblyLoadResult.IsSuccessful.get -> bool
+Microsoft.CodeAnalysis.Scripting.AssemblyLoadResult.OriginalPath.get -> string
+Microsoft.CodeAnalysis.Scripting.AssemblyLoadResult.Path.get -> string
+Microsoft.CodeAnalysis.Scripting.CompilationErrorException
+Microsoft.CodeAnalysis.Scripting.CompilationErrorException.Diagnostics.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Diagnostic>
+Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat
+Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat.Inline = 1 -> Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat
+Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat.InlineValue = 2 -> Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat
+Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat.List = 3 -> Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat
+Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat.NoMembers = 0 -> Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat
+Microsoft.CodeAnalysis.Scripting.ObjectFormatter
+Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatObject(object obj, Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions options = null) -> string
+Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatTypeName(System.Type type, Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions options) -> string
+Microsoft.CodeAnalysis.Scripting.ObjectFormatter.ObjectFormatter() -> void
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.Copy(Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat? memberFormat = null, bool? quoteStrings = null, bool? useHexadecimalNumbers = null, bool? includeCodePoints = null, int? maxLineLength = null, int? maxOutputLength = null, string memberIndentation = null, string ellipsis = null, string newLine = null) -> Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.Ellipsis.get -> string
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.IncludeCodePoints.get -> bool
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.MaxLineLength.get -> int
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.MaxOutputLength.get -> int
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.MemberFormat.get -> Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.MemberIndentation.get -> string
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.NewLine.get -> string
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.ObjectFormattingOptions(Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat memberFormat = Microsoft.CodeAnalysis.Scripting.MemberDisplayFormat.NoMembers, bool quoteStrings = true, bool useHexadecimalNumbers = false, bool includeCodePoints = false, int maxLineLength = 2147483647, int maxOutputLength = 2147483647, string memberIndentation = null, string ellipsis = null, string lineBreak = null) -> void
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.QuoteStrings.get -> bool
+Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.UseHexadecimalNumbers.get -> bool
+Microsoft.CodeAnalysis.Scripting.Script
+Microsoft.CodeAnalysis.Scripting.Script.Build(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> void
+Microsoft.CodeAnalysis.Scripting.Script.Code.get -> string
+Microsoft.CodeAnalysis.Scripting.Script.ContinueAsync(Microsoft.CodeAnalysis.Scripting.ScriptState previousState, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Scripting.ScriptState>
+Microsoft.CodeAnalysis.Scripting.Script.ContinueWith(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null) -> Microsoft.CodeAnalysis.Scripting.Script<object>
+Microsoft.CodeAnalysis.Scripting.Script.ContinueWith<TResult>(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null) -> Microsoft.CodeAnalysis.Scripting.Script<TResult>
+Microsoft.CodeAnalysis.Scripting.Script.EvaluateAsync(object globals = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<object>
+Microsoft.CodeAnalysis.Scripting.Script.GetCompilation() -> Microsoft.CodeAnalysis.Compilation
+Microsoft.CodeAnalysis.Scripting.Script.GlobalsType.get -> System.Type
+Microsoft.CodeAnalysis.Scripting.Script.Options.get -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.Script.Previous.get -> Microsoft.CodeAnalysis.Scripting.Script
+Microsoft.CodeAnalysis.Scripting.Script.RunAsync(object globals = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Scripting.ScriptState>
+Microsoft.CodeAnalysis.Scripting.Script.WithCode(string code) -> Microsoft.CodeAnalysis.Scripting.Script
+Microsoft.CodeAnalysis.Scripting.Script.WithGlobalsType(System.Type globalsType) -> Microsoft.CodeAnalysis.Scripting.Script
+Microsoft.CodeAnalysis.Scripting.Script.WithOptions(Microsoft.CodeAnalysis.Scripting.ScriptOptions options) -> Microsoft.CodeAnalysis.Scripting.Script
+Microsoft.CodeAnalysis.Scripting.Script<T>
+Microsoft.CodeAnalysis.Scripting.Script<T>.ContinueAsync(Microsoft.CodeAnalysis.Scripting.ScriptState previousState, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Scripting.ScriptState<T>>
+Microsoft.CodeAnalysis.Scripting.Script<T>.CreateDelegate(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Scripting.ScriptRunner<T>
+Microsoft.CodeAnalysis.Scripting.Script<T>.EvaluateAsync(object globals = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<T>
+Microsoft.CodeAnalysis.Scripting.Script<T>.RunAsync(object globals = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Scripting.ScriptState<T>>
+Microsoft.CodeAnalysis.Scripting.Script<T>.WithCode(string code) -> Microsoft.CodeAnalysis.Scripting.Script<T>
+Microsoft.CodeAnalysis.Scripting.Script<T>.WithGlobalsType(System.Type globalsType) -> Microsoft.CodeAnalysis.Scripting.Script<T>
+Microsoft.CodeAnalysis.Scripting.Script<T>.WithOptions(Microsoft.CodeAnalysis.Scripting.ScriptOptions options) -> Microsoft.CodeAnalysis.Scripting.Script<T>
+Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddNamespaces(System.Collections.Generic.IEnumerable<string> namespaces) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddNamespaces(params string[] namespaces) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddReferences(System.Collections.Generic.IEnumerable<System.Reflection.Assembly> references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddReferences(System.Collections.Generic.IEnumerable<string> references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddReferences(params Microsoft.CodeAnalysis.MetadataReference[] references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddReferences(params System.Reflection.Assembly[] references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddReferences(params string[] references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddSearchPaths(System.Collections.Generic.IEnumerable<string> searchPaths) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.AddSearchPaths(params string[] searchPaths) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.BaseDirectory.get -> string
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.IsInteractive.get -> bool
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.Namespaces.get -> System.Collections.Immutable.ImmutableArray<string>
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.Path.get -> string
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.ReferenceResolver.get -> Microsoft.CodeAnalysis.MetadataReferenceResolver
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.References.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference>
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.ScriptOptions() -> void
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.SearchPaths.get -> System.Collections.Immutable.ImmutableArray<string>
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithBaseDirectory(string baseDirectory) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithIsInteractive(bool isInteractive) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithNamespaces(System.Collections.Generic.IEnumerable<string> namespaces) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithNamespaces(System.Collections.Immutable.ImmutableArray<string> namespaces) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithNamespaces(params string[] namespaces) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithPath(string path) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithReferences(System.Collections.Generic.IEnumerable<System.Reflection.Assembly> references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithReferences(System.Collections.Generic.IEnumerable<string> references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithReferences(System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.MetadataReference> references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithReferences(params Microsoft.CodeAnalysis.MetadataReference[] references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithReferences(params System.Reflection.Assembly[] references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithReferences(params string[] references) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithSearchPaths(System.Collections.Generic.IEnumerable<string> searchPaths) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptOptions.WithSearchPaths(params string[] searchPaths) -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+Microsoft.CodeAnalysis.Scripting.ScriptRunner<T>
+Microsoft.CodeAnalysis.Scripting.ScriptState
+Microsoft.CodeAnalysis.Scripting.ScriptState.ContinueWithAsync(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Scripting.ScriptState<object>>
+Microsoft.CodeAnalysis.Scripting.ScriptState.ContinueWithAsync<TResult>(string code, Microsoft.CodeAnalysis.Scripting.ScriptOptions options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.Scripting.ScriptState<TResult>>
+Microsoft.CodeAnalysis.Scripting.ScriptState.ReturnValue.get -> object
+Microsoft.CodeAnalysis.Scripting.ScriptState.Script.get -> Microsoft.CodeAnalysis.Scripting.Script
+Microsoft.CodeAnalysis.Scripting.ScriptState.Variables.get -> Microsoft.CodeAnalysis.Scripting.ScriptVariables
+Microsoft.CodeAnalysis.Scripting.ScriptState<T>
+Microsoft.CodeAnalysis.Scripting.ScriptState<T>.ReturnValue.get -> T
+Microsoft.CodeAnalysis.Scripting.ScriptVariable
+Microsoft.CodeAnalysis.Scripting.ScriptVariable.Name.get -> string
+Microsoft.CodeAnalysis.Scripting.ScriptVariable.Type.get -> System.Type
+Microsoft.CodeAnalysis.Scripting.ScriptVariable.Value.get -> object
+Microsoft.CodeAnalysis.Scripting.ScriptVariables
+Microsoft.CodeAnalysis.Scripting.ScriptVariables.ContainsVariable(string name) -> bool
+Microsoft.CodeAnalysis.Scripting.ScriptVariables.Count.get -> int
+Microsoft.CodeAnalysis.Scripting.ScriptVariables.GetEnumerator() -> System.Collections.Generic.IEnumerator<Microsoft.CodeAnalysis.Scripting.ScriptVariable>
+Microsoft.CodeAnalysis.Scripting.ScriptVariables.Names.get -> System.Collections.Generic.IEnumerable<string>
+Microsoft.CodeAnalysis.Scripting.ScriptVariables.this[string name].get -> Microsoft.CodeAnalysis.Scripting.ScriptVariable
+Microsoft.CodeAnalysis.ShadowCopy
+Microsoft.CodeAnalysis.ShadowCopy.FullPath.get -> string
+Microsoft.CodeAnalysis.ShadowCopy.OriginalPath.get -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatArrayTypeName(System.Type arrayType, System.Array arrayOpt, Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions options) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatGeneratedTypeName(System.Type type) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(System.DateTime value) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(bool value) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(byte value, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(char value, bool quote, bool includeCodePoints = false, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(decimal value) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(double value) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(float value) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(int value, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(long value, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(sbyte value, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(short value, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(string value, bool quote, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(uint value, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(ulong value, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatLiteral(ushort value, bool useHexadecimalNumbers = false) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.FormatMemberName(System.Reflection.MemberInfo member) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.GenericParameterClosing.get -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.GenericParameterOpening.get -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.GetPrimitiveTypeName(Microsoft.CodeAnalysis.SpecialType type) -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.NullLiteral.get -> string
+abstract Microsoft.CodeAnalysis.Scripting.ObjectFormatter.VoidDisplayString.get -> object
+abstract Microsoft.CodeAnalysis.Scripting.Script.ReturnType.get -> System.Type
+override Microsoft.CodeAnalysis.Scripting.Script<T>.ReturnType.get -> System.Type
+static readonly Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions.Default -> Microsoft.CodeAnalysis.Scripting.ObjectFormattingOptions
+static readonly Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default -> Microsoft.CodeAnalysis.Scripting.ScriptOptions
+virtual Microsoft.CodeAnalysis.Scripting.ObjectFormatter.IsHiddenMember(System.Reflection.MemberInfo member) -> bool
\ No newline at end of file

src/Scripting/Core/ScriptBuilder.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Globalization;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
@@ -12,9 +14,9 @@
 namespace Microsoft.CodeAnalysis.Scripting
 {
     /// <summary>
-    /// Represents a runtime execution context for C# scripts.
+    /// Represents a runtime execution context for scripts.
     /// </summary>
-    internal class ScriptBuilder
+    internal sealed class ScriptBuilder
     {
         /// <summary>
         /// Unique prefix for generated assemblies.
@@ -59,16 +61,61 @@ public int GenerateSubmissionId(out string assemblyName, out string typeName)
             return id;
         }
 
+        /// <exception cref="CompilationErrorException">Compilation has errors.</exception>
+        internal Func<object[], Task<T>> CreateExecutor<T>(ScriptCompiler compiler, Compilation compilation, CancellationToken cancellationToken)
+        {
+            var diagnostics = DiagnosticBag.GetInstance();
+            try
+            {
+                // get compilation diagnostics first.
+                diagnostics.AddRange(compilation.GetParseDiagnostics());
+                if (diagnostics.HasAnyErrors())
+                {
+                    CompilationError(diagnostics, compiler.DiagnosticFormatter);
+                }
+
+                diagnostics.Clear();
+
+                var executor = Build<T>(compilation, diagnostics, cancellationToken);
+
+                // emit can fail due to compilation errors or because there is nothing to emit:
+                if (diagnostics.HasAnyErrors())
+                {
+                    CompilationError(diagnostics, compiler.DiagnosticFormatter);
+                }
+
+                if (executor == null)
+                {
+                    executor = (s) => Task.FromResult(default(T));
+                }
+
+                return executor;
+            }
+            finally
+            {
+                diagnostics.Free();
+            }
+        }
+
+        private void CompilationError(DiagnosticBag diagnostics, DiagnosticFormatter formatter)
+        {
+            var resolvedLocalDiagnostics = diagnostics.AsEnumerable();
+            var firstError = resolvedLocalDiagnostics.FirstOrDefault(d => d.Severity == DiagnosticSeverity.Error);
+            if (firstError != null)
+            {
+                throw new CompilationErrorException(formatter.Format(firstError, CultureInfo.CurrentCulture),
+                    (resolvedLocalDiagnostics.AsImmutable()));
+            }
+        }
+
         /// <summary>
         /// Builds a delegate that will execute just this scripts code.
         /// </summary>
-        public Func<object[], Task<T>> Build<T>(
-            Script script,
+        private Func<object[], Task<T>> Build<T>(
+            Compilation compilation,
             DiagnosticBag diagnostics,
             CancellationToken cancellationToken)
         {
-            var compilation = script.GetCompilation();
-
             var entryPoint = compilation.GetEntryPoint(cancellationToken);
 
             using (var peStream = new MemoryStream())