Merge pull request #10867 from tmat/Warnings46

Address netstandard1.3 warnings

build/Targets/ProducesNoOutput.Settings.targets

@@ -27,7 +27,7 @@
 
   <PropertyGroup Condition="'$(IsPortable)' != 'true'">
     <TargetFrameworkIdentifier>.NETFramework</TargetFrameworkIdentifier>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
   </PropertyGroup>
   
 </Project>
\ No newline at end of file

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LoweredDynamicOperationFactory.cs

@@ -30,7 +30,7 @@ internal LoweredDynamicOperationFactory(SyntheticBoundNodeFactory factory, int m
         // that redefines these constants and is not supposed to run existing programs.
 
         /// <summary>
-        /// Corresponds to <see cref="Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags"/>.
+        /// Corresponds to Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags.
         /// </summary>
         [Flags]
         private enum CSharpBinderFlags
@@ -48,7 +48,7 @@ private enum CSharpBinderFlags
         }
 
         /// <summary>
-        /// Corresponds to <see cref="Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags"/>.
+        /// Corresponds to Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags.
         /// </summary>
         [Flags]
         private enum CSharpArgumentInfoFlags

src/Compilers/CSharp/Portable/Symbols/Attributes/AttributeData.cs

@@ -478,8 +478,8 @@ internal void DecodeClassInterfaceAttribute(AttributeSyntax nodeOpt, DiagnosticB
             switch (interfaceType)
             {
                 case ClassInterfaceType.None:
-                case ClassInterfaceType.AutoDispatch:
-                case ClassInterfaceType.AutoDual:
+                case Cci.Constants.ClassInterfaceType_AutoDispatch:
+                case Cci.Constants.ClassInterfaceType_AutoDual:
                     break;
 
                 default:
@@ -503,8 +503,8 @@ internal void DecodeInterfaceTypeAttribute(AttributeSyntax node, DiagnosticBag d
 
             switch (interfaceType)
             {
-                case ComInterfaceType.InterfaceIsDual:
-                case ComInterfaceType.InterfaceIsIDispatch:
+                case Cci.Constants.ComInterfaceType_InterfaceIsDual:
+                case Cci.Constants.ComInterfaceType_InterfaceIsIDispatch:
                 case ComInterfaceType.InterfaceIsIInspectable:
                 case ComInterfaceType.InterfaceIsIUnknown:
                     break;

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/DynamicTypeDecoder.cs

@@ -9,7 +9,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE
 {
     /// <summary>
-    /// Decodes <see cref="System.Runtime.CompilerServices.DynamicAttribute"/> applied to a specified metadata symbol and
+    /// Decodes System.Runtime.CompilerServices.DynamicAttribute applied to a specified metadata symbol and
     /// transforms the specified metadata type, using the decoded dynamic transforms attribute argument,
     /// by replacing each occurrence of <see cref="System.Object"/> type with dynamic type.
     /// </summary>
@@ -48,10 +48,10 @@ private DynamicTypeDecoder(ImmutableArray<bool> dynamicTransformFlags, bool have
         }
 
         /// <summary>
-        /// Decodes the attributes applied to the given <see paramref="targetSymbol"/> from metadata and checks if <see cref="System.Runtime.CompilerServices.DynamicAttribute"/> is applied.
+        /// Decodes the attributes applied to the given <see paramref="targetSymbol"/> from metadata and checks if System.Runtime.CompilerServices.DynamicAttribute is applied.
         /// If so, it transforms the given <see paramref="metadataType"/>, using the decoded dynamic transforms attribute argument,
         /// by replacing each occurrence of <see cref="System.Object"/> type with dynamic type.
-        /// If no <see cref="System.Runtime.CompilerServices.DynamicAttribute"/> is applied or the decoded dynamic transforms attribute argument is erroneous,
+        /// If no System.Runtime.CompilerServices.DynamicAttribute is applied or the decoded dynamic transforms attribute argument is erroneous,
         /// returns the unchanged <see paramref="metadataType"/>.
         /// </summary>
         /// <remarks>This method is a port of TypeManager::ImportDynamicTransformType from the native compiler.</remarks>

src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs

@@ -91,7 +91,7 @@ internal bool IsMarshalAsObject
                 {
                     case UnmanagedType.Interface:
                     case UnmanagedType.IUnknown:
-                    case UnmanagedType.IDispatch:
+                    case Cci.Constants.UnmanagedType_IDispatch:
                         return true;
                 }
 

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.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.
 
-#pragma warning disable CS0618
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;

src/Compilers/Core/Portable/Interop/IVsSQM.cs

@@ -144,15 +144,18 @@ internal interface IVsSqmMulti
     {
         [return: MarshalAs(UnmanagedType.VariantBool)]
         bool GetOptInStatus();
+
         void UnloadSessions(
             );
         void EndAllSessionsAndAbortUploads(
             );
+
         void BeginSession(
             [In, MarshalAs(UnmanagedType.U4)] System.UInt32 sessionType,
             [In, MarshalAs(UnmanagedType.VariantBool)] System.Boolean alwaysSend,
             [Out, MarshalAs(UnmanagedType.U4)] out System.UInt32 sessionHandle
             );
+
         void EndSession(
             [In, MarshalAs(UnmanagedType.U4)] System.UInt32 sessionHandle
             );

src/Compilers/Core/Portable/MetadataReader/PEModule.cs

@@ -1192,8 +1192,8 @@ private static bool IsValidComInterfaceType(int comInterfaceType)
         {
             switch (comInterfaceType)
             {
-                case (int)ComInterfaceType.InterfaceIsDual:
-                case (int)ComInterfaceType.InterfaceIsIDispatch:
+                case (int)Cci.Constants.ComInterfaceType_InterfaceIsDual:
+                case (int)Cci.Constants.ComInterfaceType_InterfaceIsIDispatch:
                 case (int)ComInterfaceType.InterfaceIsIInspectable:
                 case (int)ComInterfaceType.InterfaceIsIUnknown:
                     return true;

src/Compilers/Core/Portable/PEWriter/Constants.cs

@@ -16,6 +16,17 @@ internal static class Constants
 
         // Non-portable UnmanagedType values:
         public const UnmanagedType UnmanagedType_CustomMarshaler = (UnmanagedType)44;
+        public const UnmanagedType UnmanagedType_IDispatch = (UnmanagedType)26;
+        public const UnmanagedType UnmanagedType_SafeArray = (UnmanagedType)29;
+        public const UnmanagedType UnmanagedType_VBByRefStr = (UnmanagedType)34;
+        public const UnmanagedType UnmanagedType_AnsiBStr = (UnmanagedType)35;
+        public const UnmanagedType UnmanagedType_TBStr = (UnmanagedType)36;
+
+        public const ComInterfaceType ComInterfaceType_InterfaceIsDual = 0;
+        public const ComInterfaceType ComInterfaceType_InterfaceIsIDispatch = (ComInterfaceType)2;
+
+        public const ClassInterfaceType ClassInterfaceType_AutoDispatch = (ClassInterfaceType)1;
+        public const ClassInterfaceType ClassInterfaceType_AutoDual = (ClassInterfaceType)2;
 
         // Non-portable CompilationRelaxations value:
         public const int CompilationRelaxations_NoStringInterning = 0x0008;
@@ -107,4 +118,55 @@ internal enum TypeFlags : uint
         RTSpecialNameReserved = 0x00000800,
         HasSecurityReserved = 0x00040000,
     }
+
+    /// <summary>
+    /// System.Runtime.InteropServices.VarEnum is obsolete.
+    /// </summary>
+    internal enum VarEnum
+    {
+        VT_EMPTY = 0,
+        VT_NULL = 1,
+        VT_I2 = 2,
+        VT_I4 = 3,
+        VT_R4 = 4,
+        VT_R8 = 5,
+        VT_CY = 6,
+        VT_DATE = 7,
+        VT_BSTR = 8,
+        VT_DISPATCH = 9,
+        VT_ERROR = 10,
+        VT_BOOL = 11,
+        VT_VARIANT = 12,
+        VT_UNKNOWN = 13,
+        VT_DECIMAL = 14,
+        VT_I1 = 16,
+        VT_UI1 = 17,
+        VT_UI2 = 18,
+        VT_UI4 = 19,
+        VT_I8 = 20,
+        VT_UI8 = 21,
+        VT_INT = 22,
+        VT_UINT = 23,
+        VT_VOID = 24,
+        VT_HRESULT = 25,
+        VT_PTR = 26,
+        VT_SAFEARRAY = 27,
+        VT_CARRAY = 28,
+        VT_USERDEFINED = 29,
+        VT_LPSTR = 30,
+        VT_LPWSTR = 31,
+        VT_RECORD = 36,
+        VT_FILETIME = 64,
+        VT_BLOB = 65,
+        VT_STREAM = 66,
+        VT_STORAGE = 67,
+        VT_STREAMED_OBJECT = 68,
+        VT_STORED_OBJECT = 69,
+        VT_BLOB_OBJECT = 70,
+        VT_CF = 71,
+        VT_CLSID = 72,
+        VT_VECTOR = 0x1000,
+        VT_ARRAY = 0x2000,
+        VT_BYREF = 0x4000
+    }
 }

src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs

@@ -4902,7 +4902,7 @@ private void SerializeMarshallingDescriptor(IMarshallingInformation marshallingI
 
                     break;
 
-                case UnmanagedType.SafeArray:
+                case Constants.UnmanagedType_SafeArray:
                     if (marshallingInformation.SafeArrayElementSubtype >= 0)
                     {
                         writer.WriteCompressedInteger((uint)marshallingInformation.SafeArrayElementSubtype);
@@ -4920,7 +4920,7 @@ private void SerializeMarshallingDescriptor(IMarshallingInformation marshallingI
                     break;
 
                 case UnmanagedType.Interface:
-                case UnmanagedType.IDispatch:
+                case Constants.UnmanagedType_IDispatch:
                 case UnmanagedType.IUnknown:
                     if (marshallingInformation.IidParameterIndex >= 0)
                     {

src/Compilers/Core/Portable/PEWriter/Miscellaneous.cs

@@ -3,11 +3,8 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Reflection;
-using System.Runtime.InteropServices;
-using Roslyn.Utilities;
 using EmitContext = Microsoft.CodeAnalysis.Emit.EmitContext;
 
 namespace Microsoft.Cci
@@ -166,7 +163,7 @@ short ParamIndex
         /// (The element type of a safe array is VARIANT. The "sub type" specifies the value of all of the tag fields (vt) of the element values. )
         /// -1 if it should be omitted from the marshal blob.
         /// </summary>
-        System.Runtime.InteropServices.VarEnum SafeArrayElementSubtype
+        VarEnum SafeArrayElementSubtype
         {
             get;
         }

src/Compilers/Core/Portable/Symbols/Attributes/MarshalAsAttributeDecoder.cs

@@ -25,7 +25,7 @@ internal static void Decode(ref DecodeWellKnownAttributeArguments<TAttributeSynt
                     break;
 
                 case UnmanagedType.Interface:
-                case UnmanagedType.IDispatch:
+                case Cci.Constants.UnmanagedType_IDispatch:
                 case UnmanagedType.IUnknown:
                     DecodeMarshalAsComInterface(ref arguments, unmanagedType, messageProvider);
                     break;
@@ -46,7 +46,7 @@ internal static void Decode(ref DecodeWellKnownAttributeArguments<TAttributeSynt
 
                     break;
 
-                case UnmanagedType.SafeArray:
+                case Cci.Constants.UnmanagedType_SafeArray:
                     DecodeMarshalAsSafeArray(ref arguments, messageProvider);
                     break;
 
@@ -62,7 +62,7 @@ internal static void Decode(ref DecodeWellKnownAttributeArguments<TAttributeSynt
 
                     break;
 
-                case UnmanagedType.VBByRefStr:
+                case Cci.Constants.UnmanagedType_VBByRefStr:
                     if (target == AttributeTargets.Field)
                     {
                         messageProvider.ReportMarshalUnmanagedTypeNotValidForFields(arguments.Diagnostics, arguments.AttributeSyntaxOpt, 0, "VBByRefStr", arguments.Attribute);
@@ -281,7 +281,7 @@ private static void DecodeMarshalAsSafeArray(ref DecodeWellKnownAttributeArgumen
         {
             Debug.Assert((object)arguments.AttributeSyntaxOpt != null);
 
-            VarEnum? elementTypeVariant = null;
+            Cci.VarEnum? elementTypeVariant = null;
             ITypeSymbol elementTypeSymbol = null;
             int symbolIndex = -1;
             bool hasErrors = false;
@@ -292,7 +292,7 @@ private static void DecodeMarshalAsSafeArray(ref DecodeWellKnownAttributeArgumen
                 switch (namedArg.Key)
                 {
                     case "SafeArraySubType":
-                        elementTypeVariant = namedArg.Value.DecodeValue<VarEnum>(SpecialType.System_Enum);
+                        elementTypeVariant = namedArg.Value.DecodeValue<Cci.VarEnum>(SpecialType.System_Enum);
                         if (elementTypeVariant < 0 || (int)elementTypeVariant > MarshalPseudoCustomAttributeData.MaxMarshalInteger)
                         {
                             messageProvider.ReportInvalidNamedArgument(arguments.Diagnostics, arguments.AttributeSyntaxOpt, position, arguments.Attribute.AttributeClass, namedArg.Key);
@@ -320,9 +320,9 @@ private static void DecodeMarshalAsSafeArray(ref DecodeWellKnownAttributeArgumen
 
             switch (elementTypeVariant)
             {
-                case VarEnum.VT_DISPATCH:
-                case VarEnum.VT_UNKNOWN:
-                case VarEnum.VT_RECORD:
+                case Cci.VarEnum.VT_DISPATCH:
+                case Cci.VarEnum.VT_UNKNOWN:
+                case Cci.VarEnum.VT_RECORD:
                     // only these variants accept specification of user defined subtype
                     break;
 

src/Compilers/Core/Portable/Symbols/Attributes/MarshalPseudoCustomAttributeData.cs

@@ -21,7 +21,7 @@ internal sealed class MarshalPseudoCustomAttributeData : Cci.IMarshallingInforma
 
         internal const int Invalid = -1;
         private const UnmanagedType InvalidUnmanagedType = (UnmanagedType)Invalid;
-        private const VarEnum InvalidVariantType = (VarEnum)Invalid;
+        private const Cci.VarEnum InvalidVariantType = (Cci.VarEnum)Invalid;
         internal const int MaxMarshalInteger = 0x1fffffff;
 
         #region Initialization
@@ -66,11 +66,11 @@ internal void SetMarshalAsFixedArray(UnmanagedType? elementType, int? elementCou
             _marshalArrayElementCount = elementCount ?? Invalid;
         }
 
-        internal void SetMarshalAsSafeArray(VarEnum? elementType, ITypeSymbol elementTypeSymbol)
+        internal void SetMarshalAsSafeArray(Cci.VarEnum? elementType, ITypeSymbol elementTypeSymbol)
         {
             Debug.Assert(elementType == null || elementType >= 0 && (int)elementType <= MaxMarshalInteger);
 
-            _marshalType = UnmanagedType.SafeArray;
+            _marshalType = Cci.Constants.UnmanagedType_SafeArray;
             _marshalArrayElementType = (int)(elementType ?? InvalidVariantType);
             _marshalTypeNameOrSymbol = elementTypeSymbol;
         }
@@ -103,7 +103,7 @@ int Cci.IMarshallingInformation.IidParameterIndex
                 Debug.Assert(
                     _marshalType == UnmanagedType.Interface ||
                     _marshalType == UnmanagedType.IUnknown ||
-                    _marshalType == UnmanagedType.IDispatch);
+                    _marshalType == Cci.Constants.UnmanagedType_IDispatch);
 
                 return _marshalParameterIndex;
             }
@@ -137,7 +137,7 @@ int Cci.IMarshallingInformation.NumberOfElements
         {
             get
             {
-                Debug.Assert(_marshalType == UnmanagedType.ByValTStr || _marshalType == UnmanagedType.LPArray || _marshalType == UnmanagedType.SafeArray || _marshalType == UnmanagedType.ByValArray);
+                Debug.Assert(_marshalType == UnmanagedType.ByValTStr || _marshalType == UnmanagedType.LPArray || _marshalType == Cci.Constants.UnmanagedType_SafeArray || _marshalType == UnmanagedType.ByValArray);
                 return _marshalArrayElementCount;
             }
         }
@@ -160,18 +160,18 @@ UnmanagedType Cci.IMarshallingInformation.ElementType
             }
         }
 
-        VarEnum Cci.IMarshallingInformation.SafeArrayElementSubtype
+        Cci.VarEnum Cci.IMarshallingInformation.SafeArrayElementSubtype
         {
             get
             {
-                Debug.Assert(_marshalType == UnmanagedType.SafeArray);
-                return (VarEnum)_marshalArrayElementType;
+                Debug.Assert(_marshalType == Cci.Constants.UnmanagedType_SafeArray);
+                return (Cci.VarEnum)_marshalArrayElementType;
             }
         }
 
         Cci.ITypeReference Cci.IMarshallingInformation.GetSafeArrayElementUserDefinedSubtype(EmitContext context)
         {
-            Debug.Assert(_marshalType == UnmanagedType.SafeArray);
+            Debug.Assert(_marshalType == Cci.Constants.UnmanagedType_SafeArray);
 
             if (_marshalTypeNameOrSymbol == null)
             {
@@ -189,7 +189,7 @@ Cci.ITypeReference Cci.IMarshallingInformation.GetSafeArrayElementUserDefinedSub
             Func<TTypeSymbol, TArg, TTypeSymbol> translator, TArg arg)
             where TTypeSymbol : ITypeSymbol
         {
-            if (_marshalType != UnmanagedType.SafeArray || _marshalTypeNameOrSymbol == null)
+            if (_marshalType != Cci.Constants.UnmanagedType_SafeArray || _marshalTypeNameOrSymbol == null)
             {
                 return this;
             }
@@ -201,7 +201,7 @@ Cci.ITypeReference Cci.IMarshallingInformation.GetSafeArrayElementUserDefinedSub
             }
 
             var result = new MarshalPseudoCustomAttributeData();
-            result.SetMarshalAsSafeArray((VarEnum)_marshalArrayElementType, translatedType);
+            result.SetMarshalAsSafeArray((Cci.VarEnum)_marshalArrayElementType, translatedType);
             return result;
         }
 

src/Compilers/VisualBasic/Portable/Symbols/Attributes/AttributeData.vb

@@ -423,7 +423,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                                                          CType(ctorArgument.DecodeValue(Of Short)(SpecialType.System_Int16), ClassInterfaceType))
 
             Select Case interfaceType
-                Case ClassInterfaceType.None, ClassInterfaceType.AutoDispatch, ClassInterfaceType.AutoDual
+                Case ClassInterfaceType.None, Cci.Constants.ClassInterfaceType_AutoDispatch, Cci.Constants.ClassInterfaceType_AutoDual
                     Exit Select
                 Case Else
                     diagnostics.Add(ERRID.ERR_BadAttribute1, If(nodeOpt IsNot Nothing, nodeOpt.ArgumentList.Arguments(0).GetLocation(), NoLocation.Singleton), Me.AttributeClass)
@@ -448,7 +448,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                                CType(ctorArgument.DecodeValue(Of Short)(SpecialType.System_Int16), ComInterfaceType))
 
             Select Case interfaceType
-                Case ComInterfaceType.InterfaceIsDual, ComInterfaceType.InterfaceIsIDispatch, ComInterfaceType.InterfaceIsIInspectable, ComInterfaceType.InterfaceIsIUnknown
+                Case Cci.Constants.ComInterfaceType_InterfaceIsDual, Cci.Constants.ComInterfaceType_InterfaceIsIDispatch, ComInterfaceType.InterfaceIsIInspectable, ComInterfaceType.InterfaceIsIUnknown
                     Return True
                 Case Else
                     Return False

src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb

@@ -1421,7 +1421,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
             ' Is interface marked with 'InterfaceTypeAttribute( flags with ComInterfaceType.InterfaceIsIDispatch )' attribute
             Dim interfaceType As ComInterfaceType = Nothing
             If metadataModule.HasInterfaceTypeAttribute(Me._handle, interfaceType) AndAlso
-                (interfaceType And ComInterfaceType.InterfaceIsIDispatch) <> 0 Then
+                (interfaceType And Cci.Constants.ComInterfaceType_InterfaceIsIDispatch) <> 0 Then
                 Return True
             End If
 

src/Compilers/VisualBasic/Portable/Symbols/ParameterSymbol.vb

@@ -90,7 +90,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
         Friend ReadOnly Property IsMarshalAsObject As Boolean
             Get
                 Select Case Me.MarshallingType
-                    Case UnmanagedType.Interface, UnmanagedType.IUnknown, UnmanagedType.IDispatch
+                    Case UnmanagedType.Interface, UnmanagedType.IUnknown, Cci.Constants.UnmanagedType_IDispatch
                         Return True
                 End Select
 

src/Compilers/VisualBasic/Portable/Symbols/Source/SourceNamedTypeSymbol.vb

@@ -2029,7 +2029,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                     If Not attrdata.HasErrors Then
                         Dim interfaceType As ComInterfaceType = Nothing
                         If attrdata.DecodeInterfaceTypeAttribute(interfaceType) AndAlso
-                            (interfaceType And ComInterfaceType.InterfaceIsIDispatch) <> 0 Then
+                            (interfaceType And Cci.Constants.ComInterfaceType_InterfaceIsIDispatch) <> 0 Then
 
                             arguments.GetOrCreateData(Of TypeEarlyWellKnownAttributeData).HasAttributeForExtensibleInterface = True
                         End If

src/Compilers/VisualBasic/Portable/Symbols/Source/SourceNamedTypeSymbol_ComClass.vb

@@ -988,7 +988,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                             ImmutableArray.Create(
                                 New TypedConstant(_comClass.GetSpecialType(SpecialType.System_Int16),
                                                         TypedConstantKind.Primitive,
-                                                        CShort(ComInterfaceType.InterfaceIsIDispatch)))))
+                                                        CShort(Cci.Constants.ComInterfaceType_InterfaceIsIDispatch)))))
                     End If
 
                     AddSynthesizedAttribute(attributes, compilation.TrySynthesizeAttribute(

src/Compilers/VisualBasic/Portable/Symbols/Source/SourceParameterSymbol.vb

@@ -400,10 +400,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
 
                                 Select Case pinvoke.CharacterSet
                                     Case Cci.Constants.CharSet_None, CharSet.Ansi
-                                        info.SetMarshalAsSimpleType(UnmanagedType.AnsiBStr)
+                                        info.SetMarshalAsSimpleType(Cci.Constants.UnmanagedType_AnsiBStr)
 
                                     Case Cci.Constants.CharSet_Auto
-                                        info.SetMarshalAsSimpleType(UnmanagedType.TBStr)
+                                        info.SetMarshalAsSimpleType(Cci.Constants.UnmanagedType_TBStr)
 
                                     Case CharSet.Unicode
                                         info.SetMarshalAsSimpleType(UnmanagedType.BStr)
@@ -412,7 +412,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                                         Throw ExceptionUtilities.UnexpectedValue(pinvoke.CharacterSet)
                                 End Select
                             Else
-                                info.SetMarshalAsSimpleType(UnmanagedType.VBByRefStr)
+                                info.SetMarshalAsSimpleType(Cci.Constants.UnmanagedType_VBByRefStr)
                             End If
 
                             Return info

src/Dependencies/Moq.net/project.json

@@ -4,6 +4,6 @@
      "Moq": "4.2.1402.2112"
   },
   "frameworks": {
-    ".NETFramework,Version=v4.5": { }
+    ".NETFramework,Version=v4.6": { }
   }
 }
\ No newline at end of file

src/Dependencies/VisualStudio/project.json

@@ -20,6 +20,6 @@
     "Microsoft.VisualStudio.Data.Services": "9.0.21022"
   },
   "frameworks": {
-    ".NETFramework,Version=v4.5": { }
+    ".NETFramework,Version=v4.6": { }
   }
 }
\ No newline at end of file

src/Dependencies/VisualStudioEditor/project.json

@@ -8,6 +8,6 @@
     "Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime": "14.1.24720"
   },
   "frameworks": {
-    ".NETFramework,Version=v4.5": { }
+    ".NETFramework,Version=v4.6": { }
   }
 }
\ No newline at end of file

src/Dependencies/VisualStudioText/project.json

@@ -7,6 +7,6 @@
     "Microsoft.VisualStudio.Text.UI.Wpf": "14.1.24720"
   },
   "frameworks": {
-    ".NETFramework,Version=v4.5": { }
+    ".NETFramework,Version=v4.6": { }
   }
 }
\ No newline at end of file

src/ExpressionEvaluator/Core/Source/ExpressionCompiler/DynamicFlagsCustomTypeInfo.cs

@@ -68,7 +68,7 @@ private DynamicFlagsCustomTypeInfo(ArrayBuilder<bool> dynamicFlags, int startInd
 
         /// <remarks>
         /// Not guaranteed to add the same number of flags as would
-        /// appear in a <see cref="System.Runtime.CompilerServices.DynamicAttribute"/>.
+        /// appear in a System.Runtime.CompilerServices.DynamicAttribute.
         /// It may have more (for padding) or fewer (for compactness) falses.
         /// It is, however, guaranteed to include the last true.
         /// </remarks>

src/ExpressionEvaluator/Core/Source/ResultProvider/Formatter.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.
+#pragma warning disable RS0007 // Avoid zero-length array allocations.
 
 using System;
 using System.Collections.ObjectModel;

src/ExpressionEvaluator/Core/Source/ResultProvider/Helpers/ArrayBuilder.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.
+#pragma warning disable RS0007 // Avoid zero-length array allocations.
 
 using System.Collections.Generic;
 using System.Collections.ObjectModel;

src/ExpressionEvaluator/Core/Source/ResultProvider/ResultProvider.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.
+#pragma warning disable RS0007 // Avoid zero-length array allocations.
 
 using System;
 using System.Collections.ObjectModel;

src/Test/PdbUtilities/Shared/CustomDebugInfoReader.cs

@@ -217,7 +217,7 @@ public static string DecodeForwardIteratorRecord(ImmutableArray<byte> bytes)
         }
 
         /// <summary>
-        /// Does for locals what <see cref="System.Runtime.CompilerServices.DynamicAttribute"/> does for parameters, return types, and fields.
+        /// Does for locals what System.Runtime.CompilerServices.DynamicAttribute does for parameters, return types, and fields.
         /// In particular, indicates which occurrences of <see cref="object"/> in the signature are really dynamic.
         /// </summary>
         /// <remarks>