diff --git a/src/Compilers/CSharp/Portable/CommandLine/CommandLineParser.cs b/src/Compilers/CSharp/Portable/CommandLine/CommandLineParser.cs
index 616f47556b2ca7f106f57e861359cb7bfa5378f9..b9ac575407ebbef9e5389ff41519f52882a9d221 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CommandLineParser.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CommandLineParser.cs
@@ -19,15 +19,15 @@ public class CSharpCommandLineParser : CommandLineParser
     {
         public static CSharpCommandLineParser Default { get; } = new CSharpCommandLineParser();
 
-        internal static CSharpCommandLineParser Interactive { get; } = new CSharpCommandLineParser(isInteractive: true);
+        public static CSharpCommandLineParser Interactive { get; } = new CSharpCommandLineParser(isInteractive: true);
 
         internal CSharpCommandLineParser(bool isInteractive = false)
             : base(CSharp.MessageProvider.Instance, isInteractive)
         {
         }
 
-        internal override string RegularFileExtension { get { return ".cs"; } }
-        internal override string ScriptFileExtension { get { return ".csx"; } }
+        protected override string RegularFileExtension { get { return ".cs"; } }
+        protected override string ScriptFileExtension { get { return ".csx"; } }
 
         internal sealed override CommandLineArguments CommonParse(IEnumerable<string> args, string baseDirectory, string sdkDirectory, string additionalReferenceDirectories)
         {
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index d5c90fc125e5f29a121c9a6d14a965dc61270757..01d28b6d76e6e415217e0fb4b77ece45b2b1884c 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -208,7 +208,7 @@ public override INamedTypeSymbol CreateErrorTypeSymbol(INamespaceOrTypeSymbol co
         /// <summary>
         /// Creates a new compilation that can be used in scripting.
         /// </summary>
-        internal static CSharpCompilation CreateSubmission(
+        public static CSharpCompilation CreateSubmission(
             string assemblyName,
             SyntaxTree syntaxTree = null,
             IEnumerable<MetadataReference> references = null,
@@ -2673,7 +2673,7 @@ protected override Compilation CommonWithAssemblyName(string assemblyName)
             return WithAssemblyName(assemblyName);
         }
 
-        internal override ITypeSymbol CommonGetSubmissionResultType(out bool hasValue)
+        protected override ITypeSymbol CommonGetSubmissionResultType(out bool hasValue)
         {
             return GetSubmissionResultType(out hasValue);
         }
@@ -2693,7 +2693,7 @@ protected override CompilationOptions CommonOptions
             get { return _options; }
         }
 
-        internal override Compilation CommonPreviousSubmission
+        protected override Compilation CommonPreviousSubmission
         {
             get { return _previousSubmission; }
         }
@@ -2758,7 +2758,7 @@ protected override Compilation CommonWithOptions(CompilationOptions options)
             return this.WithOptions((CSharpCompilationOptions)options);
         }
 
-        internal override Compilation CommonWithPreviousSubmission(Compilation newPreviousSubmission)
+        protected override Compilation CommonWithPreviousSubmission(Compilation newPreviousSubmission)
         {
             return this.WithPreviousSubmission((CSharpCompilation)newPreviousSubmission);
         }
@@ -2798,7 +2798,7 @@ protected override INamedTypeSymbol CommonGetTypeByMetadataName(string metadataN
             return this.GetTypeByMetadataName(metadataName);
         }
 
-        internal override INamedTypeSymbol CommonScriptClass
+        protected override INamedTypeSymbol CommonScriptClass
         {
             get { return this.ScriptClass; }
         }
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.txt b/src/Compilers/CSharp/Portable/PublicAPI.txt
index 6573eb1ea0fd08ade98a709e1031dc79f5556525..f79fec81068bf64201b99f0d5a076d9fa69bcf7c 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.txt
@@ -3230,8 +3230,10 @@ override Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax.Accept<TResul
 override sealed Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ToFullString() -> string
 override sealed Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode.ToString() -> string
 static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Default.get -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser
+static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Interactive.get -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser
 static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.ParseConditionalCompilationSymbols(string value, out System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic> diagnostics) -> System.Collections.Generic.IEnumerable<string>
 static Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create(string assemblyName, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTree> syntaxTrees = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references = null, Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions options = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
+static Microsoft.CodeAnalysis.CSharp.CSharpCompilation.CreateSubmission(string assemblyName, Microsoft.CodeAnalysis.SyntaxTree syntaxTree = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> references = null, Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions options = null, Microsoft.CodeAnalysis.Compilation previousSubmission = null, System.Type returnType = null, System.Type hostObjectType = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCompilation
 static Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter.Instance.get -> Microsoft.CodeAnalysis.CSharp.CSharpDiagnosticFormatter
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax firstStatement, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax lastStatement) -> Microsoft.CodeAnalysis.ControlFlowAnalysis
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.AnalyzeControlFlow(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement) -> Microsoft.CodeAnalysis.ControlFlowAnalysis
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs b/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
index 40f04ca9f71f06371ea6e8937c05c2b9f48f558a..e5de96a598f1bc9c416d8df4a3ee31a7aaab1108 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCommandLineArguments.cs
@@ -173,7 +173,7 @@ public abstract class CommandLineArguments
         /// <summary>
         /// Arguments following script argument separator "--" or null if <see cref="IsInteractive"/> is false.
         /// </summary>
-        internal ImmutableArray<string> ScriptArguments { get; set; }
+        public ImmutableArray<string> ScriptArguments { get; internal set; }
 
         /// <summary>
         /// Source file paths.
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCommandLineParser.cs b/src/Compilers/Core/Portable/CommandLine/CommonCommandLineParser.cs
index 746dcb121fa55fb1ecf283beb5cfc4c8e394ae8c..18f16bd38ee5bf33d7676a4af319ce47e1959045 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCommandLineParser.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCommandLineParser.cs
@@ -32,13 +32,13 @@ internal CommonMessageProvider MessageProvider
             get { return _messageProvider; }
         }
 
-        internal bool IsInteractive
+        public bool IsInteractive
         {
             get { return _isInteractive; }
         }
 
-        internal abstract string RegularFileExtension { get; }
-        internal abstract string ScriptFileExtension { get; }
+        protected abstract string RegularFileExtension { get; }
+        protected abstract string ScriptFileExtension { get; }
 
         // internal for testing
         internal virtual TextReader CreateTextFileReader(string fullPath)
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index 0f14dbcfe9881950e9453b84c3f87071d8f49c3e..f8a8616e644e6555844b0a587a2dfbbd87a99dce 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -377,32 +377,32 @@ internal static bool IsValidHostObjectType(Type type)
         /// <paramref name="hasValue"/> is false in the former case and true
         /// in the latter.
         /// </remarks>
-        internal ITypeSymbol GetSubmissionResultType(out bool hasValue)
+        public ITypeSymbol GetSubmissionResultType(out bool hasValue)
         {
             return CommonGetSubmissionResultType(out hasValue);
         }
 
-        internal abstract ITypeSymbol CommonGetSubmissionResultType(out bool hasValue);
+        protected abstract ITypeSymbol CommonGetSubmissionResultType(out bool hasValue);
 
         /// <summary>
         /// The previous submission compilation, or null if either this
         /// compilation doesn't represent a submission or the submission is the
         /// first submission in a submission chain.
         /// </summary>
-        internal Compilation PreviousSubmission { get { return CommonPreviousSubmission; } }
+        public Compilation PreviousSubmission { get { return CommonPreviousSubmission; } }
 
-        internal abstract Compilation CommonPreviousSubmission { get; }
+        protected abstract Compilation CommonPreviousSubmission { get; }
 
         /// <summary>
         /// Returns a new compilation with the given compilation set as the
         /// previous submission.
         /// </summary>
-        internal Compilation WithPreviousSubmission(Compilation newPreviousSubmission)
+        public Compilation WithPreviousSubmission(Compilation newPreviousSubmission)
         {
             return CommonWithPreviousSubmission(newPreviousSubmission);
         }
 
-        internal abstract Compilation CommonWithPreviousSubmission(Compilation newPreviousSubmission);
+        protected abstract Compilation CommonWithPreviousSubmission(Compilation newPreviousSubmission);
 
         #endregion
 
@@ -839,8 +839,8 @@ public INamedTypeSymbol GetSpecialType(SpecialType specialType)
         /// A symbol representing the implicit Script class. This is null if the class is not
         /// defined in the compilation.
         /// </summary>
-        internal INamedTypeSymbol ScriptClass { get { return CommonScriptClass; } }
-        internal abstract INamedTypeSymbol CommonScriptClass { get; }
+        public INamedTypeSymbol ScriptClass { get { return CommonScriptClass; } }
+        protected abstract INamedTypeSymbol CommonScriptClass { get; }
 
         /// <summary>
         /// Returns a new ArrayTypeSymbol representing an array type tied to the base types of the
diff --git a/src/Compilers/Core/Portable/PublicAPI.txt b/src/Compilers/Core/Portable/PublicAPI.txt
index a57de93bb246b45bf3f753473809a54dd5a9bd36..c8dc9f09f8a521a18af4c8ac92c5d9935d7a0421 100644
--- a/src/Compilers/Core/Portable/PublicAPI.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.txt
@@ -130,6 +130,7 @@ Microsoft.CodeAnalysis.CommandLineArguments.ReferencePaths.get -> System.Collect
 Microsoft.CodeAnalysis.CommandLineArguments.ReportAnalyzer.get -> bool
 Microsoft.CodeAnalysis.CommandLineArguments.ResolveAnalyzerReferences(Microsoft.CodeAnalysis.IAnalyzerAssemblyLoader analyzerLoader) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference>
 Microsoft.CodeAnalysis.CommandLineArguments.ResolveMetadataReferences(Microsoft.CodeAnalysis.MetadataReferenceResolver metadataResolver) -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference>
+Microsoft.CodeAnalysis.CommandLineArguments.ScriptArguments.get -> System.Collections.Immutable.ImmutableArray<string>
 Microsoft.CodeAnalysis.CommandLineArguments.SourceFiles.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.CommandLineSourceFile>
 Microsoft.CodeAnalysis.CommandLineArguments.TouchedFilesPath.get -> string
 Microsoft.CodeAnalysis.CommandLineArguments.Utf8Output.get -> bool
@@ -137,6 +138,7 @@ Microsoft.CodeAnalysis.CommandLineArguments.Win32Icon.get -> string
 Microsoft.CodeAnalysis.CommandLineArguments.Win32Manifest.get -> string
 Microsoft.CodeAnalysis.CommandLineArguments.Win32ResourceFile.get -> string
 Microsoft.CodeAnalysis.CommandLineParser
+Microsoft.CodeAnalysis.CommandLineParser.IsInteractive.get -> bool
 Microsoft.CodeAnalysis.CommandLineParser.Parse(System.Collections.Generic.IEnumerable<string> args, string baseDirectory, string sdkDirectory, string additionalReferenceDirectories) -> Microsoft.CodeAnalysis.CommandLineArguments
 Microsoft.CodeAnalysis.CommandLineReference
 Microsoft.CodeAnalysis.CommandLineReference.Equals(Microsoft.CodeAnalysis.CommandLineReference other) -> bool
@@ -168,10 +170,12 @@ Microsoft.CodeAnalysis.Compilation.GetEntryPoint(System.Threading.CancellationTo
 Microsoft.CodeAnalysis.Compilation.GetMetadataReference(Microsoft.CodeAnalysis.IAssemblySymbol assemblySymbol) -> Microsoft.CodeAnalysis.MetadataReference
 Microsoft.CodeAnalysis.Compilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree syntaxTree, bool ignoreAccessibility = false) -> Microsoft.CodeAnalysis.SemanticModel
 Microsoft.CodeAnalysis.Compilation.GetSpecialType(Microsoft.CodeAnalysis.SpecialType specialType) -> Microsoft.CodeAnalysis.INamedTypeSymbol
+Microsoft.CodeAnalysis.Compilation.GetSubmissionResultType(out bool hasValue) -> Microsoft.CodeAnalysis.ITypeSymbol
 Microsoft.CodeAnalysis.Compilation.GetTypeByMetadataName(string fullyQualifiedMetadataName) -> Microsoft.CodeAnalysis.INamedTypeSymbol
 Microsoft.CodeAnalysis.Compilation.GlobalNamespace.get -> Microsoft.CodeAnalysis.INamespaceSymbol
 Microsoft.CodeAnalysis.Compilation.ObjectType.get -> Microsoft.CodeAnalysis.INamedTypeSymbol
 Microsoft.CodeAnalysis.Compilation.Options.get -> Microsoft.CodeAnalysis.CompilationOptions
+Microsoft.CodeAnalysis.Compilation.PreviousSubmission.get -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.Compilation.References.get -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference>
 Microsoft.CodeAnalysis.Compilation.RemoveAllReferences() -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.Compilation.RemoveAllSyntaxTrees() -> Microsoft.CodeAnalysis.Compilation
@@ -181,10 +185,12 @@ Microsoft.CodeAnalysis.Compilation.RemoveSyntaxTrees(System.Collections.Generic.
 Microsoft.CodeAnalysis.Compilation.RemoveSyntaxTrees(params Microsoft.CodeAnalysis.SyntaxTree[] trees) -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.Compilation.ReplaceReference(Microsoft.CodeAnalysis.MetadataReference oldReference, Microsoft.CodeAnalysis.MetadataReference newReference) -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.Compilation.ReplaceSyntaxTree(Microsoft.CodeAnalysis.SyntaxTree oldTree, Microsoft.CodeAnalysis.SyntaxTree newTree) -> Microsoft.CodeAnalysis.Compilation
+Microsoft.CodeAnalysis.Compilation.ScriptClass.get -> Microsoft.CodeAnalysis.INamedTypeSymbol
 Microsoft.CodeAnalysis.Compilation.SourceModule.get -> Microsoft.CodeAnalysis.IModuleSymbol
 Microsoft.CodeAnalysis.Compilation.SyntaxTrees.get -> System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxTree>
 Microsoft.CodeAnalysis.Compilation.WithAssemblyName(string assemblyName) -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.Compilation.WithOptions(Microsoft.CodeAnalysis.CompilationOptions options) -> Microsoft.CodeAnalysis.Compilation
+Microsoft.CodeAnalysis.Compilation.WithPreviousSubmission(Microsoft.CodeAnalysis.Compilation newPreviousSubmission) -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.Compilation.WithReferences(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.MetadataReference> newReferences) -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.Compilation.WithReferences(params Microsoft.CodeAnalysis.MetadataReference[] newReferences) -> Microsoft.CodeAnalysis.Compilation
 Microsoft.CodeAnalysis.CompilationOptions
diff --git a/src/Compilers/VisualBasic/Portable/CommandLine/CommandLineParser.vb b/src/Compilers/VisualBasic/Portable/CommandLine/CommandLineParser.vb
index cc35731004b7888867bcaed6ab4d5b4f1079fb28..1ef6df8e9253940df01d3ebb87016d0949693502 100644
--- a/src/Compilers/VisualBasic/Portable/CommandLine/CommandLineParser.vb
+++ b/src/Compilers/VisualBasic/Portable/CommandLine/CommandLineParser.vb
@@ -25,7 +25,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' <summary>
         ''' Gets the current interactive command line parser.
         ''' </summary>
-        Friend Shared ReadOnly Property Interactive As VisualBasicCommandLineParser = New VisualBasicCommandLineParser(isInteractive:=True)
+        Public Shared ReadOnly Property Interactive As VisualBasicCommandLineParser = New VisualBasicCommandLineParser(isInteractive:=True)
 
         ''' <summary>
         ''' Creates a new command line parser.
@@ -43,7 +43,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' Gets the standard Visual Basic source file extension
         ''' </summary>
         ''' <returns>A string representing the standard Visual Basic source file extension.</returns>
-        Friend Overrides ReadOnly Property RegularFileExtension As String
+        Protected Overrides ReadOnly Property RegularFileExtension As String
             Get
                 Return ".vb"
             End Get
@@ -53,7 +53,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' Gets the standard Visual Basic script file extension.
         ''' </summary>
         ''' <returns>A string representing the standard Visual Basic script file extension.</returns>
-        Friend Overrides ReadOnly Property ScriptFileExtension As String
+        Protected Overrides ReadOnly Property ScriptFileExtension As String
             Get
                 Return ".vbx"
             End Get
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
index e3546b30c8536b5480bb9c462bd3e6180e6996da..044c9208ca9ecd7b1aece0e122e1bff732f296de 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
@@ -320,7 +320,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' <summary> 
         ''' Creates a new compilation that can be used in scripting. 
         ''' </summary>
-        Friend Shared Function CreateSubmission(
+        Public Shared Function CreateSubmission(
             assemblyName As String,
             Optional syntaxTree As SyntaxTree = Nothing,
             Optional references As IEnumerable(Of MetadataReference) = Nothing,
@@ -2474,7 +2474,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return WithAssemblyName(assemblyName)
         End Function
 
-        Friend Overrides Function CommonGetSubmissionResultType(ByRef hasValue As Boolean) As ITypeSymbol
+        Protected Overrides Function CommonGetSubmissionResultType(ByRef hasValue As Boolean) As ITypeSymbol
             Return GetSubmissionResultType(hasValue)
         End Function
 
@@ -2496,7 +2496,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
-        Friend Overrides ReadOnly Property CommonPreviousSubmission As Compilation
+        Protected Overrides ReadOnly Property CommonPreviousSubmission As Compilation
             Get
                 Return PreviousSubmission
             End Get
@@ -2550,7 +2550,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return Me.WithOptions(DirectCast(options, VisualBasicCompilationOptions))
         End Function
 
-        Friend Overrides Function CommonWithPreviousSubmission(newPreviousSubmission As Compilation) As Compilation
+        Protected Overrides Function CommonWithPreviousSubmission(newPreviousSubmission As Compilation) As Compilation
             Return Me.WithPreviousSubmission(DirectCast(newPreviousSubmission, VisualBasicCompilation))
         End Function
 
@@ -2584,7 +2584,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return Me.GetTypeByMetadataName(metadataName)
         End Function
 
-        Friend Overrides ReadOnly Property CommonScriptClass As INamedTypeSymbol
+        Protected Overrides ReadOnly Property CommonScriptClass As INamedTypeSymbol
             Get
                 Return Me.ScriptClass
             End Get
diff --git a/src/Compilers/VisualBasic/Portable/PublicAPI.txt b/src/Compilers/VisualBasic/Portable/PublicAPI.txt
index d519fc95d62ea0bea76cd33cbc4f2ed997da5f54..85e831d099649869a0eafb1d2cfdfc007655af87 100644
--- a/src/Compilers/VisualBasic/Portable/PublicAPI.txt
+++ b/src/Compilers/VisualBasic/Portable/PublicAPI.txt
@@ -4353,6 +4353,8 @@ Overrides Microsoft.CodeAnalysis.VisualBasic.Syntax.XmlTextSyntax.Accept(Of TRes
 Overrides Microsoft.CodeAnalysis.VisualBasic.Syntax.XmlTextSyntax.Accept(visitor As Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor) -> Void
 Overrides Microsoft.CodeAnalysis.VisualBasic.Syntax.YieldStatementSyntax.Accept(Of TResult)(visitor As Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor(Of TResult)) -> TResult
 Overrides Microsoft.CodeAnalysis.VisualBasic.Syntax.YieldStatementSyntax.Accept(visitor As Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor) -> Void
+Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.RegularFileExtension() -> String
+Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.ScriptFileExtension() -> String
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.ContainsSymbolsWithName(predicate As System.Func(Of String, Boolean), filter As Microsoft.CodeAnalysis.SymbolFilter = Microsoft.CodeAnalysis.SymbolFilter.TypeAndMember, cancellationToken As System.Threading.CancellationToken = Nothing) -> Boolean
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CreateErrorTypeSymbol(container As Microsoft.CodeAnalysis.INamespaceOrTypeSymbol, name As String, arity As Integer) -> Microsoft.CodeAnalysis.INamedTypeSymbol
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.DirectiveReferences() -> System.Collections.Immutable.ImmutableArray(Of Microsoft.CodeAnalysis.MetadataReference)
@@ -5833,7 +5835,8 @@ Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFacts.MakeHalfWidthIdentifier(te
 Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFacts.VarianceKindFromToken(token As Microsoft.CodeAnalysis.SyntaxToken) -> Microsoft.CodeAnalysis.VarianceKind
 Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.ParseConditionalCompilationSymbols(symbolList As String, ByRef diagnostics As System.Collections.Generic.IEnumerable(Of Microsoft.CodeAnalysis.Diagnostic), symbols As System.Collections.Generic.IEnumerable(Of System.Collections.Generic.KeyValuePair(Of String, Object)) = Nothing) -> System.Collections.Generic.IReadOnlyDictionary(Of String, Object)
 Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.Create(assemblyName As String, syntaxTrees As System.Collections.Generic.IEnumerable(Of Microsoft.CodeAnalysis.SyntaxTree) = Nothing, references As System.Collections.Generic.IEnumerable(Of Microsoft.CodeAnalysis.MetadataReference) = Nothing, options As Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions = Nothing) -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation
+Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.CreateSubmission(assemblyName As String, syntaxTree As Microsoft.CodeAnalysis.SyntaxTree = Nothing, references As System.Collections.Generic.IEnumerable(Of Microsoft.CodeAnalysis.MetadataReference) = Nothing, options As Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions = Nothing, previousSubmission As Microsoft.CodeAnalysis.Compilation = Nothing, returnType As System.Type = Nothing, hostObjectType As System.Type = Nothing) -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation
 Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxNode.DeserializeFrom(stream As System.IO.Stream, cancellationToken As System.Threading.CancellationToken = Nothing) -> Microsoft.CodeAnalysis.SyntaxNode
 Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.Create(root As Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxNode, options As Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions = Nothing, path As String = "", encoding As System.Text.Encoding = Nothing) -> Microsoft.CodeAnalysis.SyntaxTree
 Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(text As Microsoft.CodeAnalysis.Text.SourceText, options As Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions = Nothing, path As String = "", cancellationToken As System.Threading.CancellationToken = Nothing) -> Microsoft.CodeAnalysis.SyntaxTree
-Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(text As String, options As Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions = Nothing, path As String = "", encoding As System.Text.Encoding = Nothing, cancellationToken As System.Threading.CancellationToken = Nothing) -> Microsoft.CodeAnalysis.SyntaxTree
+Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(text As String, options As Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions = Nothing, path As String = "", encoding As System.Text.Encoding = Nothing, cancellationToken As System.Threading.CancellationToken = Nothing) -> Microsoft.CodeAnalysis.SyntaxTree
\ No newline at end of file
diff --git a/src/EditorFeatures/CSharpTest/Interactive/CodeActions/InteractiveIntroduceVariableTests.cs b/src/EditorFeatures/CSharpTest/Interactive/CodeActions/InteractiveIntroduceVariableTests.cs
index fdddd4b5297dd595ec4ed0266c0f47aef5d3343b..629e31786882586c32ce712158bfb8f1e7c8e32f 100644
--- a/src/EditorFeatures/CSharpTest/Interactive/CodeActions/InteractiveIntroduceVariableTests.cs
+++ b/src/EditorFeatures/CSharpTest/Interactive/CodeActions/InteractiveIntroduceVariableTests.cs
@@ -18,7 +18,7 @@ protected void Test(string initial, string expected, int index = 0, bool compare
             Test(initial, expected, Options.Script, index, compareTokens);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/2888"), Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public void TestMethodFix1()
         {
             Test(
@@ -27,7 +27,7 @@ public void TestMethodFix1()
                 index: 2);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/2888"), Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public void TestMethodFix2()
         {
             Test(
@@ -36,7 +36,7 @@ public void TestMethodFix2()
                 index: 3);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/2888"), Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public void TestFieldFix1()
         {
             var code =
@@ -49,7 +49,7 @@ public void TestFieldFix1()
             Test(code, expected, index: 0, compareTokens: false);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/2888"), Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public void TestFieldFix2()
         {
             var code =
@@ -62,7 +62,7 @@ public void TestFieldFix2()
             Test(code, expected, index: 1, compareTokens: false);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/2888"), Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public void TestParameterFix1()
         {
             Test(
@@ -71,7 +71,7 @@ public void TestParameterFix1()
                 index: 0);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/2888"), Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public void TestParameterFix2()
         {
             Test(
@@ -80,7 +80,7 @@ public void TestParameterFix2()
                 index: 1);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/2888")]
+        [Fact]
         public void TestAttributeFix1()
         {
             Test(
@@ -89,7 +89,7 @@ public void TestAttributeFix1()
                 index: 0);
         }
 
-        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/2888"), Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public void TestAttributeFix2()
         {
             Test(
diff --git a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.FieldSymbols.vb b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.FieldSymbols.vb
index a32c3abe2fb839298b990e21410c76561c7af195..966ff38e065f0a97a512fa51f68041be92295153 100644
--- a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.FieldSymbols.vb
+++ b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.FieldSymbols.vb
@@ -337,7 +337,7 @@ class Program
         End Sub
 
         <WorkItem(540515)>
-        <Fact(Skip:="https://github.com/dotnet/roslyn/issues/2888"), Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
         Public Sub Field_AcrossSubmission()
             Dim input =
 <Workspace>
diff --git a/src/Features/CSharp/IntroduceVariable/CSharpIntroduceVariableService_IntroduceField.cs b/src/Features/CSharp/IntroduceVariable/CSharpIntroduceVariableService_IntroduceField.cs
index fa8ae2524af3d572fd7dba2f0e0f6fe25ccba532..0f9c9862315da7f105683b36e64399bf232ec743 100644
--- a/src/Features/CSharp/IntroduceVariable/CSharpIntroduceVariableService_IntroduceField.cs
+++ b/src/Features/CSharp/IntroduceVariable/CSharpIntroduceVariableService_IntroduceField.cs
@@ -23,13 +23,9 @@ internal partial class CSharpIntroduceVariableService
         {
             var oldTypeDeclaration = expression.GetAncestorOrThis<TypeDeclarationSyntax>();
 
-#if SCRIPTING
             var oldType = oldTypeDeclaration != null
                 ? document.SemanticModel.GetDeclaredSymbol(oldTypeDeclaration, cancellationToken) as INamedTypeSymbol
                 : document.SemanticModel.Compilation.ScriptClass;
-#else
-            var oldType = document.SemanticModel.GetDeclaredSymbol(oldTypeDeclaration, cancellationToken) as INamedTypeSymbol;
-#endif
             var newNameToken = (SyntaxToken)GenerateUniqueFieldName(document, expression, isConstant, cancellationToken);
 
             var newQualifiedName = oldTypeDeclaration != null
diff --git a/src/Features/Core/IntroduceVariable/AbstractIntroduceVariableService.State.cs b/src/Features/Core/IntroduceVariable/AbstractIntroduceVariableService.State.cs
index 10256651e74a0c2c7ddd4b33cb6e977b894026c3..e5b595bdc17fa787fe4cea1997ac65e0e5fcd168 100644
--- a/src/Features/Core/IntroduceVariable/AbstractIntroduceVariableService.State.cs
+++ b/src/Features/Core/IntroduceVariable/AbstractIntroduceVariableService.State.cs
@@ -75,9 +75,8 @@ public State(TService service, SemanticDocument document)
                     .OfType<INamedTypeSymbol>()
                     .FirstOrDefault();
 
-#if SCRIPTING
                 containingType = containingType ?? this.Document.SemanticModel.Compilation.ScriptClass;
-#endif
+
                 if (containingType == null || containingType.TypeKind == TypeKind.Interface)
                 {
                     return false;
@@ -242,12 +241,10 @@ private TExpressionSyntax GetExpressionUnderSpan(SyntaxTree tree, TextSpan textS
             private bool CanGenerateInto<TSyntax>(CancellationToken cancellationToken)
                 where TSyntax : SyntaxNode
             {
-#if SCRIPTING
                 if (this.Document.SemanticModel.Compilation.ScriptClass != null)
                 {
                     return true;
                 }
-#endif
 
                 var syntax = this.Expression.GetAncestor<TSyntax>();
                 return syntax != null && !syntax.OverlapsHiddenPosition(cancellationToken);
@@ -260,13 +257,12 @@ private bool IsInTypeDeclarationOrValidCompilationUnit()
                     return true;
                 }
 
-#if SCRIPTING
                 // If we're interactive/script, we can generate into the compilation unit.
                 if (this.Document.Document.SourceCodeKind != SourceCodeKind.Regular)
                 {
                     return true;
                 }
-#endif
+
                 return false;
             }
         }
diff --git a/src/Interactive/EditorFeatures/CSharp/Interactive/CSharpInteractiveEvaluator.cs b/src/Interactive/EditorFeatures/CSharp/Interactive/CSharpInteractiveEvaluator.cs
index 8f24c6b25e08c96e1e8cddca59b6e4155fce6701..0b9febca237cf70fd087183f56203e7d86c88d93 100644
--- a/src/Interactive/EditorFeatures/CSharp/Interactive/CSharpInteractiveEvaluator.cs
+++ b/src/Interactive/EditorFeatures/CSharp/Interactive/CSharpInteractiveEvaluator.cs
@@ -75,11 +75,7 @@ public override bool CanExecuteCode(string text)
 
         protected override CommandLineParser CommandLineParser
         {
-#if SCRIPTING
             get { return CSharpCommandLineParser.Interactive; }
-#else
-            get { return CSharpCommandLineParser.Default; }
-#endif
         }
     }
 }
diff --git a/src/Interactive/EditorFeatures/CSharp/Interactive/CSharpRepl.cs b/src/Interactive/EditorFeatures/CSharp/Interactive/CSharpRepl.cs
index 10bc71133442709d0e764b96daa043eae1ff3b14..dd410e8437290e5e97c9e307043742d49d22c813 100644
--- a/src/Interactive/EditorFeatures/CSharp/Interactive/CSharpRepl.cs
+++ b/src/Interactive/EditorFeatures/CSharp/Interactive/CSharpRepl.cs
@@ -32,11 +32,7 @@ public string GetLogo()
 
         public CommandLineParser GetCommandLineParser()
         {
-#if SCRIPTING
             return CSharpCommandLineParser.Interactive;
-#else
-            return CSharpCommandLineParser.Default;
-#endif
         }
 
         public DiagnosticFormatter GetDiagnosticFormatter()
diff --git a/src/Interactive/EditorFeatures/VisualBasic/Interactive/VisualBasicInteractiveEvaluator.vb b/src/Interactive/EditorFeatures/VisualBasic/Interactive/VisualBasicInteractiveEvaluator.vb
index 05c0e83ff03631b0fadb42d59405fb315e15baf9..b191f56d4d416ce01c3b4f95d8d7e7bd3eec69ec 100644
--- a/src/Interactive/EditorFeatures/VisualBasic/Interactive/VisualBasicInteractiveEvaluator.vb
+++ b/src/Interactive/EditorFeatures/VisualBasic/Interactive/VisualBasicInteractiveEvaluator.vb
@@ -51,11 +51,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.Interactive
 
         Protected Overrides ReadOnly Property CommandLineParser As CommandLineParser
             Get
-#If SCRIPTING Then
                 Return VisualBasicCommandLineParser.Interactive
-#Else
-                Return VisualBasicCommandLineParser.Default
-#End If
             End Get
         End Property
 
diff --git a/src/Interactive/EditorFeatures/VisualBasic/Interactive/VisualBasicRepl.vb b/src/Interactive/EditorFeatures/VisualBasic/Interactive/VisualBasicRepl.vb
index 7597f53e6566fac817189c906f0b338768d54903..f6d6bf20a63370dd2b8d8bb3c8f6688d3916c7b3 100644
--- a/src/Interactive/EditorFeatures/VisualBasic/Interactive/VisualBasicRepl.vb
+++ b/src/Interactive/EditorFeatures/VisualBasic/Interactive/VisualBasicRepl.vb
@@ -26,11 +26,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.Interactive
         End Function
 
         Public Function GetCommandLineParser() As CommandLineParser Implements IRepl.GetCommandLineParser
-#If SCRIPTING Then
             Return VisualBasicCommandLineParser.Interactive
-#Else
-            Return VisualBasicCommandLineParser.Default
-#End If
         End Function
 
         Public Function GetDiagnosticFormatter() As DiagnosticFormatter Implements IRepl.GetDiagnosticFormatter
diff --git a/src/Interactive/Features/Interactive/Core/InteractiveHost.Service.cs b/src/Interactive/Features/Interactive/Core/InteractiveHost.Service.cs
index 021a2da801097f30d3375aef810934c9c0cb8482..ac62390d978b958e4eedaad1b32d00de61330cf6 100644
--- a/src/Interactive/Features/Interactive/Core/InteractiveHost.Service.cs
+++ b/src/Interactive/Features/Interactive/Core/InteractiveHost.Service.cs
@@ -748,7 +748,7 @@ private bool Execute(string text)
                 }
 
                 bool hasValue;
-                var resultType = _getSubmissionResultType(script.GetCompilation(), out hasValue);
+                var resultType = script.GetCompilation().GetSubmissionResultType(out hasValue);
                 if (hasValue)
                 {
                     if (resultType != null && resultType.SpecialType == SpecialType.System_Void)
@@ -764,10 +764,6 @@ private bool Execute(string text)
                 return true;
             }
 
-            // TODO: replace by direct call to GetSubmissionResultType when it becomes public
-            private delegate ITypeSymbol GetSubmissionResultTypeDelegate(Compilation compilation, out bool hasValue);
-            private GetSubmissionResultTypeDelegate _getSubmissionResultType = typeof(Compilation).GetTypeInfo().GetDeclaredMethod("GetSubmissionResultType").CreateDelegate<GetSubmissionResultTypeDelegate>();
-
             private class ExecuteSubmissionError
             {
                 public readonly Exception Exception;
diff --git a/src/Scripting/Core/Scripting.csproj b/src/Scripting/Core/Scripting.csproj
index 5375b0a62f7c54fa24bc504e064125d6d8337826..22aca9fd1adc5e4c032efed7a76115e49f475e2f 100644
--- a/src/Scripting/Core/Scripting.csproj
+++ b/src/Scripting/Core/Scripting.csproj
@@ -205,4 +205,4 @@
     <Import Project="..\..\..\build\VSL.Imports.Closed.targets" />
     <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   </ImportGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/Workspaces/CSharp/Portable/LanguageServices/CSharpCompilationFactoryService.cs b/src/Workspaces/CSharp/Portable/LanguageServices/CSharpCompilationFactoryService.cs
index e8e023a051b55ff28ddef168da24ceb389b80fed..324dd17b817ed8b088686c24eefe8dd785501774 100644
--- a/src/Workspaces/CSharp/Portable/LanguageServices/CSharpCompilationFactoryService.cs
+++ b/src/Workspaces/CSharp/Portable/LanguageServices/CSharpCompilationFactoryService.cs
@@ -22,15 +22,11 @@ Compilation ICompilationFactoryService.CreateCompilation(string assemblyName, Co
 
         Compilation ICompilationFactoryService.CreateSubmissionCompilation(string assemblyName, CompilationOptions options, Type hostObjectType)
         {
-#if SCRIPTING
             return CSharpCompilation.CreateSubmission(
                 assemblyName,
                 options: (CSharpCompilationOptions)options,
                 previousSubmission: null,
                 hostObjectType: hostObjectType);
-#else
-            throw new NotImplementedException();
-#endif
         }
 
         Compilation ICompilationFactoryService.GetCompilationFromCompilationReference(MetadataReference reference)
diff --git a/src/Workspaces/CSharp/Portable/LanguageServices/CSharpHostBuildDataFactory.cs b/src/Workspaces/CSharp/Portable/LanguageServices/CSharpHostBuildDataFactory.cs
index 058313da7f819321ae526bd1ae3e7fd96b4f5d77..c0e6260eacece039fbd2b050bfa1833dadec3be4 100644
--- a/src/Workspaces/CSharp/Portable/LanguageServices/CSharpHostBuildDataFactory.cs
+++ b/src/Workspaces/CSharp/Portable/LanguageServices/CSharpHostBuildDataFactory.cs
@@ -16,11 +16,7 @@ internal sealed class CSharpCommandLineParserFactory : ICommandLineArgumentsFact
     {
         public CommandLineArguments CreateCommandLineArguments(IEnumerable<string> arguments, string baseDirectory, bool isInteractive, string sdkDirectory)
         {
-#if SCRIPTING
             var parser = isInteractive ? CSharpCommandLineParser.Interactive : CSharpCommandLineParser.Default;
-#else
-            var parser = CSharpCommandLineParser.Default;
-#endif
             return parser.Parse(arguments, baseDirectory, sdkDirectory);
         }
     }
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentProjectsFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentProjectsFinder.cs
index 6b76f89c61eb86d494866d81ba576d8af8440177..d6d97336524f52971ac589ac281dc4972cca8d50 100644
--- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentProjectsFinder.cs
+++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentProjectsFinder.cs
@@ -192,11 +192,10 @@ private static IEnumerable<Project> GetProjects(Solution solution, IEnumerable<P
                 await AddNonSubmissionDependentProjectsAsync(symbol.ContainingAssembly, solution, sourceProject, dependentProjects, cancellationToken).ConfigureAwait(false);
             }
 
-#if SCRIPTING
             // submission projects are special here. The fields generated inside the Script object
             // is private, but further submissions can bind to them.
             await AddSubmissionDependentProjectsAsync(solution, sourceProject, dependentProjects, cancellationToken).ConfigureAwait(false);
-#endif
+
             return dependentProjects;
         }
 
@@ -218,7 +217,6 @@ private static IEnumerable<Project> GetProjects(Solution solution, IEnumerable<P
             return GetProjects(solution, projectIds);
         }
 
-#if SCRIPTING
         private static async Task AddSubmissionDependentProjectsAsync(Solution solution, Project sourceProject, HashSet<DependentProject> dependentProjects, CancellationToken cancellationToken)
         {
             var isSubmission = sourceProject != null && sourceProject.IsSubmission;
@@ -280,7 +278,7 @@ private static async Task AddSubmissionDependentProjectsAsync(Solution solution,
                 }
             }
         }
-#endif
+
         private static bool IsInternalsVisibleToAttribute(AttributeData attr)
         {
             var attrType = attr.AttributeClass;
diff --git a/src/Workspaces/Core/Portable/PublicAPI.txt b/src/Workspaces/Core/Portable/PublicAPI.txt
index d1029dae559e29950d0f060c649aedcf8679827b..db23ccac43e8993ab94bb43a007c41e0dd2742dc 100644
--- a/src/Workspaces/Core/Portable/PublicAPI.txt
+++ b/src/Workspaces/Core/Portable/PublicAPI.txt
@@ -524,6 +524,7 @@ Microsoft.CodeAnalysis.Project.GetLatestDocumentVersionAsync(System.Threading.Ca
 Microsoft.CodeAnalysis.Project.GetSemanticVersionAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.VersionStamp>
 Microsoft.CodeAnalysis.Project.HasDocuments.get -> bool
 Microsoft.CodeAnalysis.Project.Id.get -> Microsoft.CodeAnalysis.ProjectId
+Microsoft.CodeAnalysis.Project.IsSubmission.get -> bool
 Microsoft.CodeAnalysis.Project.Language.get -> string
 Microsoft.CodeAnalysis.Project.LanguageServices.get -> Microsoft.CodeAnalysis.Host.HostLanguageServices
 Microsoft.CodeAnalysis.Project.MetadataReferences.get -> System.Collections.Generic.IReadOnlyList<Microsoft.CodeAnalysis.MetadataReference>
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
index 320b2e42fbd32d0b6df6d6fbf55268d5b25affd5..d5172ee68a320eceebc685d059376c57b4b8099d 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
@@ -221,7 +221,7 @@ public ParseOptions ParseOptions
         /// <summary>
         /// Returns true if this is a submission project.
         /// </summary>
-        internal bool IsSubmission
+        public bool IsSubmission
         {
             get
             {
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Solution.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Solution.CompilationTracker.cs
index c841e48edfe08a276c0c99e96a4677663325b9a0..485898f1a87d214465560140b91db39e7df4f33d 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Solution.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Solution.CompilationTracker.cs
@@ -247,14 +247,12 @@ public CompilationTracker FreezePartialStateWithTree(Solution solution, Document
                     var referencedProject = solution.GetProject(projectReference.ProjectId);
                     if (referencedProject != null)
                     {
-#if SCRIPTING
                         if (referencedProject.IsSubmission)
                         {
                             var compilation = solution.GetCompilationAsync(projectReference.ProjectId, cancellationToken).WaitAndGetResult(cancellationToken);
                             inProgressCompilation = inProgressCompilation.WithPreviousSubmission(compilation);
                         }
                         else
-#endif
                         {
                             // get the latest metadata for the partial compilation of the referenced project.
                             var metadata = solution.GetPartialMetadataReference(projectReference, this.ProjectState, cancellationToken);
@@ -505,7 +503,6 @@ private Compilation CreateEmptyCompilation()
             {
                 var compilationFactory = this.ProjectState.LanguageServices.GetService<ICompilationFactoryService>();
 
-#if SCRIPTING
                 if (this.ProjectState.IsSubmission)
                 {
                     return compilationFactory.CreateSubmissionCompilation(
@@ -514,7 +511,6 @@ private Compilation CreateEmptyCompilation()
                         this.ProjectState.HostObjectType);
                 }
                 else
-#endif
                 {
                     return compilationFactory.CreateCompilation(
                         this.ProjectState.AssemblyName,
@@ -588,7 +584,6 @@ private Compilation CreateEmptyCompilation()
                         {
                             // If both projects are submissions, we'll count this as a previous submission link
                             // instead of a regular metadata reference
-#if SCRIPTING
                             if (referencedProject.IsSubmission)
                             {
                                 // if the referenced project is a submission project must be a submission as well:
@@ -599,7 +594,6 @@ private Compilation CreateEmptyCompilation()
                                 compilation = compilation.WithPreviousSubmission(previousSubmissionCompilation);
                             }
                             else
-#endif
                             {
                                 var metadataReference = await solution.GetMetadataReferenceAsync(
                                     projectReference, this.ProjectState, cancellationToken).ConfigureAwait(false);
diff --git a/src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicCompilationFactoryService.vb b/src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicCompilationFactoryService.vb
index 68de64ff45a4ccebb541e15df2850a9c83503b1b..515449fb9e316c4d4e5be0ba1b11b77b3021724b 100644
--- a/src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicCompilationFactoryService.vb
+++ b/src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicCompilationFactoryService.vb
@@ -25,14 +25,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             assemblyName As String,
             options As CompilationOptions,
             hostObjectType As Type) As Compilation Implements ICompilationFactoryService.CreateSubmissionCompilation
-#If SCRIPTING Then
+
             Return VisualBasicCompilation.CreateSubmission(
                 assemblyName,
                 options:=DirectCast(options, VisualBasicCompilationOptions),
                 hostObjectType:=hostObjectType)
-#Else
-            Throw New NotImplementedException()
-#End If
         End Function
 
         Private Function ICompilationFactoryService_GetCompilationFromCompilationReference(reference As MetadataReference) As Compilation Implements ICompilationFactoryService.GetCompilationFromCompilationReference
diff --git a/src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicHostBuildDataFactory.vb b/src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicHostBuildDataFactory.vb
index eae2086b272b287377a918c0bacf4d1a5fa8dde9..f26deece51861becd1577116f77e01ea4fbd9252 100644
--- a/src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicHostBuildDataFactory.vb
+++ b/src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicHostBuildDataFactory.vb
@@ -19,11 +19,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Implements ICommandLineArgumentsFactoryService
 
         Public Function CreateCommandLineArguments(arguments As IEnumerable(Of String), baseDirectory As String, isInteractive As Boolean, sdkDirectory As String) As CommandLineArguments Implements ICommandLineArgumentsFactoryService.CreateCommandLineArguments
-#If SCRIPTING Then
             Dim parser = If(isInteractive, VisualBasicCommandLineParser.Interactive, VisualBasicCommandLineParser.Default)
-#Else
-            Dim parser = VisualBasicCommandLineParser.Default
-#End If
             Return parser.Parse(arguments, baseDirectory, sdkDirectory)
         End Function
     End Class