Merge remote-tracking branch 'dotnet/features/ioperation' into remove…

…-literal-text

* dotnet/features/ioperation:
  Fix NamedArgumentInParameterOrderWithDefaultValue test for new IOperation output.
  EnC and EE cleanup (dotnet#21226)
  Fix crash when encountering a parenthesized expression when converting an if to a switch.
  this makes OOM to crash OOP process. this won't crash VS, instead it will show info bar and notify users to close VS and re-open.
  Turn on ref assemblies in all projects (dotnet#21346)
  Re-baseline some emit tests
  Move MakeFrames logic into Analysis
  Use langver=latest for scripting (dotnet#21331)
  Enable skipped tests and fix them (dotnet#21335)
  Replace project reference with linked file
  removed left out from deleted esent code.

build/Targets/Settings.props

@@ -22,6 +22,7 @@
     <RoslynPortableTargetFrameworks>net46;netcoreapp2.0</RoslynPortableTargetFrameworks>
 
     <Features>strict,IOperation</Features>
+    <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
     <Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>
     <SignAssembly>true</SignAssembly>
     <!-- The new SDK introduced a GenerateAssemblyInfo target, which is disabled by GenerateAssemblyInfo=false.

build/scripts/build.ps1

@@ -347,6 +347,10 @@ function Test-XUnit() {
     # Exclude out the multi-targetted netcore app projects
     $dlls = $dlls | ?{ -not ($_.FullName -match ".*netcoreapp.*") }
 
+    # Exclude out the ref assemblies
+    $dlls = $dlls | ?{ -not ($_.FullName -match ".*\\ref\\.*") }
+    $dlls = $dlls | ?{ -not ($_.FullName -match ".*/ref/.*") }
+
     if ($cibuild) {
         # Use a 50 minute timeout on CI
         $args += " -xml -timeout:50"

src/Compilers/CSharp/Portable/CSharpParseOptions.cs

@@ -61,7 +61,7 @@ public override IEnumerable<string> PreprocessorSymbolNames
             LanguageVersion languageVersion,
             DocumentationMode documentationMode,
             SourceCodeKind kind,
-            IEnumerable<string> preprocessorSymbols,
+            ImmutableArray<string> preprocessorSymbols,
             IReadOnlyDictionary<string, string> features)
             : base(kind, documentationMode)
         {

src/Compilers/CSharp/Portable/Compiler/TypeCompilationState.cs

@@ -66,7 +66,7 @@ internal MethodWithBody(MethodSymbol method, BoundStatement body, ImportChain im
 
         public readonly CSharpCompilation Compilation;
 
-        public LambdaFrame StaticLambdaFrame;
+        public ClosureEnvironment StaticLambdaFrame;
 
         /// <summary>
         /// A graph of method->method references for this(...) constructor initializers.

src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpDefinitionMap.cs

@@ -183,16 +183,13 @@ internal override bool TryGetPropertyHandle(Cci.IPropertyDefinition def, out Pro
             awaiterSlotCount = maxAwaiterSlotIndex + 1;
         }
 
-        protected override ImmutableArray<EncLocalInfo> TryGetLocalSlotMapFromMetadata(MethodDefinitionHandle handle, EditAndContinueMethodDebugInformation debugInfo)
+        protected override ImmutableArray<EncLocalInfo> GetLocalSlotMapFromMetadata(StandaloneSignatureHandle handle, EditAndContinueMethodDebugInformation debugInfo)
         {
-            ImmutableArray<LocalInfo<TypeSymbol>> slotMetadata;
-            if (!_metadataDecoder.TryGetLocals(handle, out slotMetadata))
-            {
-                return default(ImmutableArray<EncLocalInfo>);
-            }
+            Debug.Assert(!handle.IsNil);
 
-            var result = CreateLocalSlotMap(debugInfo, slotMetadata);
-            Debug.Assert(result.Length == slotMetadata.Length);
+            var localInfos = _metadataDecoder.GetLocalsOrThrow(handle);
+            var result = CreateLocalSlotMap(debugInfo, localInfos);
+            Debug.Assert(result.Length == localInfos.Length);
             return result;
         }
 

src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaCapturedVariable.cs

@@ -31,7 +31,7 @@ private LambdaCapturedVariable(SynthesizedContainer frame, TypeSymbol type, stri
             _isThis = isThisParameter;
         }
 
-        public static LambdaCapturedVariable Create(LambdaFrame frame, Symbol captured, ref int uniqueId)
+        public static LambdaCapturedVariable Create(ClosureEnvironment frame, Symbol captured, ref int uniqueId)
         {
             Debug.Assert(captured is LocalSymbol || captured is ParameterSymbol);
 
@@ -87,7 +87,7 @@ private static TypeSymbol GetCapturedVariableFieldType(SynthesizedContainer fram
             if ((object)local != null)
             {
                 // if we're capturing a generic frame pointer, construct it with the new frame's type parameters
-                var lambdaFrame = local.Type.OriginalDefinition as LambdaFrame;
+                var lambdaFrame = local.Type.OriginalDefinition as ClosureEnvironment;
                 if ((object)lambdaFrame != null)
                 {
                     // lambdaFrame may have less generic type parameters than frame, so trim them down (the first N will always match)

src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaFrame.cs

@@ -1,44 +1,58 @@
 // 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.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
     /// <summary>
     /// A class that represents the set of variables in a scope that have been
-    /// captured by lambdas within that scope.
+    /// captured by nested functions within that scope.
     /// </summary>
-    internal sealed class LambdaFrame : SynthesizedContainer, ISynthesizedMethodBodyImplementationSymbol
+    internal sealed class ClosureEnvironment : SynthesizedContainer, ISynthesizedMethodBodyImplementationSymbol
     {
-        private readonly TypeKind _typeKind;
         private readonly MethodSymbol _topLevelMethod;
-        private readonly MethodSymbol _containingMethod;
-        private readonly MethodSymbol _constructor;
-        private readonly MethodSymbol _staticConstructor;
-        private readonly FieldSymbol _singletonCache;
         internal readonly SyntaxNode ScopeSyntaxOpt;
         internal readonly int ClosureOrdinal;
-
-        internal LambdaFrame(MethodSymbol topLevelMethod, MethodSymbol containingMethod, bool isStruct, SyntaxNode scopeSyntaxOpt, DebugId methodId, DebugId closureId)
+        /// <summary>
+        /// The closest method/lambda that this frame is originally from. Null if nongeneric static closure.
+        /// Useful because this frame's type parameters are constructed from this method and all methods containing this method.
+        /// </summary>
+        internal readonly MethodSymbol OriginalContainingMethodOpt;
+        internal readonly FieldSymbol SingletonCache;
+        internal readonly MethodSymbol StaticConstructor;
+        public readonly IEnumerable<Symbol> CapturedVariables;
+
+        public override TypeKind TypeKind { get; }
+        internal override MethodSymbol Constructor { get; }
+
+        internal ClosureEnvironment(
+            IEnumerable<Symbol> capturedVariables,
+            MethodSymbol topLevelMethod,
+            MethodSymbol containingMethod,
+            bool isStruct,
+            SyntaxNode scopeSyntaxOpt,
+            DebugId methodId,
+            DebugId closureId)
             : base(MakeName(scopeSyntaxOpt, methodId, closureId), containingMethod)
         {
-            _typeKind = isStruct ? TypeKind.Struct : TypeKind.Class;
+            CapturedVariables = capturedVariables;
+            TypeKind = isStruct ? TypeKind.Struct : TypeKind.Class;
             _topLevelMethod = topLevelMethod;
-            _containingMethod = containingMethod;
-            _constructor = isStruct ? null : new LambdaFrameConstructor(this);
+            OriginalContainingMethodOpt = containingMethod;
+            Constructor = isStruct ? null : new LambdaFrameConstructor(this);
             this.ClosureOrdinal = closureId.Ordinal;
 
             // static lambdas technically have the class scope so the scope syntax is null 
             if (scopeSyntaxOpt == null)
             {
-                _staticConstructor = new SynthesizedStaticConstructor(this);
+                StaticConstructor = new SynthesizedStaticConstructor(this);
                 var cacheVariableName = GeneratedNames.MakeCachedFrameInstanceFieldName();
-                _singletonCache = new SynthesizedLambdaCacheFieldSymbol(this, this, cacheVariableName, topLevelMethod, isReadOnly: true, isStatic: true);
+                SingletonCache = new SynthesizedLambdaCacheFieldSymbol(this, this, cacheVariableName, topLevelMethod, isReadOnly: true, isStatic: true);
             }
 
             AssertIsClosureScopeSyntax(scopeSyntaxOpt);
@@ -77,69 +91,25 @@ private static void AssertIsClosureScopeSyntax(SyntaxNode syntaxOpt)
             throw ExceptionUtilities.UnexpectedValue(syntaxOpt.Kind());
         }
 
-        public override TypeKind TypeKind
-        {
-            get { return _typeKind; }
-        }
-
-        internal override MethodSymbol Constructor
-        {
-            get { return _constructor; }
-        }
-
-        internal MethodSymbol StaticConstructor
-        {
-            get { return _staticConstructor; }
-        }
-
-        /// <summary>
-        /// The closest method/lambda that this frame is originally from. Null if nongeneric static closure.
-        /// Useful because this frame's type parameters are constructed from this method and all methods containing this method.
-        /// </summary>
-        internal MethodSymbol ContainingMethod
-        {
-            get { return _containingMethod; }
-        }
-
         public override ImmutableArray<Symbol> GetMembers()
         {
             var members = base.GetMembers();
-            if ((object)_staticConstructor != null)
+            if ((object)StaticConstructor != null)
             {
-                members = ImmutableArray.Create<Symbol>(_staticConstructor, _singletonCache).AddRange(members);
+                members = ImmutableArray.Create<Symbol>(StaticConstructor, SingletonCache).AddRange(members);
             }
 
             return members;
         }
 
-        internal FieldSymbol SingletonCache
-        {
-            get { return _singletonCache; }
-        }
-
         // display classes for static lambdas do not have any data and can be serialized.
-        internal override bool IsSerializable
-        {
-            get { return (object)_singletonCache != null; }
-        }
+        internal override bool IsSerializable => (object)SingletonCache != null;
 
-        public override Symbol ContainingSymbol
-        {
-            get { return _topLevelMethod.ContainingSymbol; }
-        }
+        public override Symbol ContainingSymbol => _topLevelMethod.ContainingSymbol;
 
-        bool ISynthesizedMethodBodyImplementationSymbol.HasMethodBodyDependency
-        {
-            get
-            {
-                // the lambda method contains user code from the lambda:
-                return true;
-            }
-        }
+        // The lambda method contains user code from the lambda
+        bool ISynthesizedMethodBodyImplementationSymbol.HasMethodBodyDependency => true;
 
-        IMethodSymbol ISynthesizedMethodBodyImplementationSymbol.Method
-        {
-            get { return _topLevelMethod; }
-        }
+        IMethodSymbol ISynthesizedMethodBodyImplementationSymbol.Method => _topLevelMethod;
     }
 }

src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaFrameConstructor.cs

@@ -6,7 +6,7 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     internal sealed class LambdaFrameConstructor : SynthesizedInstanceConstructor, ISynthesizedMethodBodyImplementationSymbol
     {
-        internal LambdaFrameConstructor(LambdaFrame frame)
+        internal LambdaFrameConstructor(ClosureEnvironment frame)
             : base(frame)
         {
         }