diff --git a/.editorconfig b/.editorconfig
index c0b880906c654..8a1b92e426ed8 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -47,6 +47,75 @@ dotnet_style_coalesce_expression = true:suggestion
dotnet_style_null_propagation = true:suggestion
dotnet_style_explicit_tuple_names = true:suggestion
+# Non-private static fields are PascalCase
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.symbols = non_private_static_fields
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.style = non_private_static_field_style
+
+dotnet_naming_symbols.non_private_static_fields.applicable_kinds = field
+dotnet_naming_symbols.non_private_static_fields.applicable_accessibilities = public, protected, internal, protected internal, private protected
+dotnet_naming_symbols.non_private_static_fields.required_modifiers = static
+
+dotnet_naming_style.non_private_static_field_style.capitalization = pascal_case
+
+# Constants are PascalCase
+dotnet_naming_rule.constants_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.constants_should_be_pascal_case.symbols = constants
+dotnet_naming_rule.constants_should_be_pascal_case.style = constant_style
+
+dotnet_naming_symbols.constants.applicable_kinds = field, local
+dotnet_naming_symbols.constants.required_modifiers = const
+
+dotnet_naming_style.constant_style.capitalization = pascal_case
+
+# Static fields are camelCase and start with s_
+dotnet_naming_rule.static_fields_should_be_camel_case.severity = suggestion
+dotnet_naming_rule.static_fields_should_be_camel_case.symbols = static_fields
+dotnet_naming_rule.static_fields_should_be_camel_case.style = static_field_style
+
+dotnet_naming_symbols.static_fields.applicable_kinds = field
+dotnet_naming_symbols.static_fields.required_modifiers = static
+
+dotnet_naming_style.static_field_style.capitalization = camel_case
+dotnet_naming_style.static_field_style.required_prefix = s_
+
+# Instance fields are camelCase and start with _
+dotnet_naming_rule.instance_fields_should_be_camel_case.severity = suggestion
+dotnet_naming_rule.instance_fields_should_be_camel_case.symbols = instance_fields
+dotnet_naming_rule.instance_fields_should_be_camel_case.style = instance_field_style
+
+dotnet_naming_symbols.instance_fields.applicable_kinds = field
+
+dotnet_naming_style.instance_field_style.capitalization = camel_case
+dotnet_naming_style.instance_field_style.required_prefix = _
+
+# Locals and parameters are camelCase
+dotnet_naming_rule.locals_should_be_camel_case.severity = suggestion
+dotnet_naming_rule.locals_should_be_camel_case.symbols = locals_and_parameters
+dotnet_naming_rule.locals_should_be_camel_case.style = camel_case_style
+
+dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local
+
+dotnet_naming_style.camel_case_style.capitalization = camel_case
+
+# Local functions are PascalCase
+dotnet_naming_rule.local_functions_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions
+dotnet_naming_rule.local_functions_should_be_pascal_case.style = local_function_style
+
+dotnet_naming_symbols.local_functions.applicable_kinds = local_function
+
+dotnet_naming_style.local_function_style.capitalization = pascal_case
+
+# By default, name items with PascalCase
+dotnet_naming_rule.members_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.members_should_be_pascal_case.symbols = all_members
+dotnet_naming_rule.members_should_be_pascal_case.style = pascal_case_style
+
+dotnet_naming_symbols.all_members.applicable_kinds = *
+
+dotnet_naming_style.pascal_case_style.capitalization = pascal_case
+
# CSharp code style settings:
[*.cs]
# Indentation preferences
diff --git a/.gitattributes b/.gitattributes
index e8917806a306d..996fe676587fb 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -2,16 +2,6 @@
# Set default behavior to automatically normalize line endings.
###############################################################################
* text=auto encoding=UTF-8
-
-# RunCsc/RunVbc are shell scripts and should always have unix line endings
-# These shell scripts are included in the toolset packages. Normally, the shell
-# scripts in our repo are only run by cloning onto a Linux/Mac machine, and git
-# automatically chooses LF as the line ending.
-#
-# However, right now the toolset packages must be built on Windows, and so the
-# files must be hard-coded to be cloned with LF
-build/NuGetAdditionalFiles/RunCsc text eol=lf
-build/NuGetAdditionalFiles/RunVbc text eol=lf
*.sh text eol=lf
###############################################################################
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
deleted file mode 100644
index f1aaa7c60112d..0000000000000
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ /dev/null
@@ -1,44 +0,0 @@
-Ask Mode template not completed
-
-
-
-### Customer scenario
-
-What does the customer do to get into this situation, and why do we think this
-is common enough to address for this release. (Granted, sometimes this will be
-obvious "Open project, VS crashes" but in general, I need to understand how
-common a scenario is)
-
-### Bugs this fixes
-
-(either VSO or GitHub links)
-
-### Workarounds, if any
-
-Also, why we think they are insufficient for RC vs. RC2, RC3, or RTW
-
-### Risk
-
-This is generally a measure our how central the affected code is to adjacent
-scenarios and thus how likely your fix is to destabilize a broader area of code
-
-### Performance impact
-
-(with a brief justification for that assessment (e.g. "Low perf impact because no extra allocations/no complexity changes" vs. "Low")
-
-### Is this a regression from a previous update?
-
-### Root cause analysis
-
-How did we miss it? What tests are we adding to guard against it in the future?
-
-### How was the bug found?
-
-(E.g. customer reported it vs. ad hoc testing)
-
-### Test documentation updated?
-
-If this is a new non-compiler feature or a significant improvement to an existing feature, update https://github.com/dotnet/roslyn/wiki/Manual-Testing once you know which release it is targeting.
-
-
diff --git a/.vsts-ci.yml b/.vsts-ci.yml
index f1f357584f0eb..54d5fffebe4ac 100644
--- a/.vsts-ci.yml
+++ b/.vsts-ci.yml
@@ -44,7 +44,7 @@ steps:
/p:TreatWarningsAsErrors=true
/p:DeployExtension=false
/p:TrackFileAccess=false
- /p:OfficialBuild=true
+ /p:OfficialBuildId=$(BUILD.BUILDNUMBER)
/p:VisualStudioVersion=14.0
/flp1:Summary;Verbosity=diagnostic;Encoding=UTF-8;LogFile=$(Build.SourcesDirectory)\Binaries\$(BuildConfiguration)\Roslyn.log
/flp2:WarningsOnly;Verbosity=diagnostic;Encoding=UTF-8;LogFile=$(Build.SourcesDirectory)\Binaries\$(BuildConfiguration)\Roslyn.wrn
@@ -57,12 +57,15 @@ steps:
/p:PB_PublishBlobFeedKey=$(PB_PublishBlobFeedKey)
/p:PublishStableVersions=false
/p:VersionStampToPublish=prerelease
+ /p:DotNetSymbolServerTokenMsdl=$(microsoft-symbol-server-pat)
+ /p:DotNetSymbolServerTokenSymWeb=$(symweb-symbol-server-pat)
platform: '$(BuildPlatform)'
configuration: '$(BuildConfiguration)'
maximumCpuCount: true
logProjectEvents: false
- task: PublishBuildArtifacts@1
+ displayName: Publish Logs
inputs:
PathtoPublish: '$(Build.SourcesDirectory)\Binaries\$(BuildConfiguration)\Logs'
ArtifactName: 'Build Diagnostic Files'
@@ -71,6 +74,7 @@ steps:
condition: succeededOrFailed()
- task: PublishTestResults@1
+ displayName: Publish Test Results
inputs:
testRunner: XUnit
testResultsFiles: '**/xUnitResults/*.xml'
@@ -78,40 +82,10 @@ steps:
testRunTitle: 'Unit Tests'
condition: succeededOrFailed()
-- task: PublishSymbols@1
- displayName: Create Symbol Index
- inputs:
- SymbolsPath: '$(DropRoot)\Roslyn-Signed\$(Build.SourceBranchName)\$(BuildConfiguration)\$(Build.BuildNumber)\Symbols'
- SearchPattern: '**\*.dll;**\*.exe;**\*.pdb'
- SymbolsFolder: '$(Build.SourcesDirectory)\Binaries\$(BuildConfiguration)\SymStore'
- SkipIndexing: true
- TreatNotIndexedAsWarning: true
- SymbolsProduct: Roslyn
- SymbolsVersion: '$(Build.BuildNumber)'
- SymbolsArtifactName: Symbols
- condition: and(succeeded(), contains(variables['PB_PublishType'], 'vsts'))
-
-- task: CopyFiles@2
- displayName: Copy Files to Local Temporary Path
- inputs:
- SourceFolder: '$(DropRoot)\Roslyn-Signed\$(Build.SourceBranchName)\$(BuildConfiguration)\$(Build.BuildNumber)\Symbols'
- TargetFolder: '$(Build.StagingDirectory)\SymbolsForPublish'
- condition: and(succeeded(), contains(variables['PB_PublishType'], 'vsts'))
-
-- task: ms-vscs-artifact.build-tasks.artifactSymbolTask-1.artifactSymbolTask@0
- displayName: Publish Symbols to Artifact Services
- inputs:
- symbolServiceURI: 'https://microsoft.artifacts.visualstudio.com/DefaultCollection'
- requestName: '$(system.teamProject)/Roslyn-Signed/$(Build.BuildNumber)/$(Build.BuildId)'
- sourcePath: '$(Build.StagingDirectory)\SymbolsForPublish'
- usePat: false
- continueOnError: true
- condition: and(succeeded(), contains(variables['PB_PublishType'], 'vsts'))
-
- task: ms-vseng.MicroBuildTasks.4305a8de-ba66-4d8b-b2d1-0dc4ecbbf5e8.MicroBuildUploadVstsDropFolder@1
displayName: Upload VSTS Drop
inputs:
- DropFolder: 'Binaries\$(BuildConfiguration)\Insertion'
+ DropFolder: 'Binaries\VSSetup\$(BuildConfiguration)\Insertion'
condition: and(succeeded(), contains(variables['PB_PublishType'], 'vsts'))
- task: NuGetCommand@2
@@ -124,8 +98,10 @@ steps:
allowPackageConflicts: true
condition: and(succeeded(), contains(variables['PB_PublishType'], 'vsts'))
+# Publish VSTS artifact that the RoslynInsertionTool is able to find by its name.
+# The backing storage of the artifact is a file share.
- task: PublishBuildArtifacts@1
- displayName: Publish Drop (parallel)
+ displayName: Publish Drop - Binaries
inputs:
PathtoPublish: 'Binaries\$(BuildConfiguration)'
ArtifactName: '$(Build.BuildNumber)'
@@ -133,6 +109,15 @@ steps:
TargetPath: '$(DropRoot)\Roslyn-Signed\$(Build.SourceBranchName)\$(BuildConfiguration)'
Parallel: true
ParallelCount: 64
+ condition: succeededOrFailed()
+
+# Copy additional files to the drop directory
+- task: PowerShell@2
+ displayName: Publish Drop - VSSetup
+ inputs:
+ arguments: '-Source Binaries\VSSetup\$(BuildConfiguration)\Insertion -Target $(DropRoot)\Roslyn-Signed\$(Build.SourceBranchName)\$(BuildConfiguration)\$(Build.BuildNumber)\Insertion -ParallelCount 8'
+ filePath: 'build\scripts\vsts-robocopy.ps1'
+ condition: succeededOrFailed()
- task: ms-vseng.MicroBuildTasks.521a94ea-9e68-468a-8167-6dcf361ea776.MicroBuildCleanup@1
displayName: Perform Cleanup Tasks
diff --git a/.vsts-dnceng.yml b/.vsts-dnceng.yml
new file mode 100644
index 0000000000000..32d2ba1f9e975
--- /dev/null
+++ b/.vsts-dnceng.yml
@@ -0,0 +1,129 @@
+phases:
+- phase: Windows_Desktop_Unit_Tests
+ queue:
+ name: Helix
+ timeoutInMinutes: 90
+ parallel: 4
+ matrix:
+ debug_32:
+ _configuration: Debug
+ _testKind: Test32
+ debug_64:
+ _configuration: Debug
+ _testKind: Test64
+ release_32:
+ _configuration: Release
+ _testKind: Test32
+ release_64:
+ _configuration: Release
+ _testKind: Test64
+
+ steps:
+ - script: build/scripts/cibuild.cmd -$(_configuration) -testDesktop -$(_testKind)
+
+ - task: PublishTestResults@1
+ inputs:
+ testRunner: XUnit
+ testResultsFiles: '**/xUnitResults/*.xml'
+ mergeTestResults: true
+ testRunTitle: 'Windows Desktop $(_configuration) $(_testKind)'
+ condition: succeededOrFailed()
+
+ - task: PublishBuildArtifacts@1
+ inputs:
+ PathtoPublish: '$(Build.SourcesDirectory)\Binaries\$(_configuration)\Logs'
+ ArtifactName: 'Windows Desktop $(_configuration) $(_testKind)'
+ publishLocation: Container
+ continueOnError: true
+ condition: failed()
+
+- phase: Windows_CoreClr_Unit_Tests
+ queue:
+ name: Helix
+ timeoutInMinutes: 90
+ parallel: 2
+ matrix:
+ debug:
+ _configuration: Debug
+ release:
+ _configuration: Release
+
+ steps:
+ - script: build/scripts/cibuild.cmd -$(_configuration) -testCoreClr -buildCoreClr
+
+ - task: PublishTestResults@1
+ inputs:
+ testRunner: XUnit
+ testResultsFiles: '**/xUnitResults/*.xml'
+ mergeTestResults: true
+ testRunTitle: 'Windows CoreClr $(_configuration)'
+ condition: succeededOrFailed()
+
+ - task: PublishBuildArtifacts@1
+ inputs:
+ PathtoPublish: '$(Build.SourcesDirectory)\Binaries\$(_configuration)\Logs'
+ ArtifactName: 'Windows CoreClr $(_configuration)'
+ publishLocation: Container
+ continueOnError: true
+ condition: failed()
+
+- phase: Windows_Determinism_Test
+ queue:
+ name: Helix
+ timeoutInMinutes: 90
+ steps:
+ - script: build/scripts/cibuild.cmd -testDeterminism
+
+ - task: PublishBuildArtifacts@1
+ inputs:
+ PathtoPublish: '$(Build.SourcesDirectory)\Binaries\Debug\Logs'
+ ArtifactName: 'Build Determinism Files'
+ publishLocation: Container
+ continueOnError: true
+ condition: failed()
+
+- phase: Windows_Correctness_Test
+ queue:
+ name: Helix
+ timeoutInMinutes: 90
+ steps:
+ - script: build/scripts/test-build-correctness.cmd -cibuild -release
+
+ - task: PublishBuildArtifacts@1
+ inputs:
+ PathtoPublish: '$(Build.SourcesDirectory)\Binaries\Release\Logs'
+ ArtifactName: 'Build Correctness Files'
+ publishLocation: Container
+ continueOnError: true
+ condition: failed()
+
+- phase: Linux_Test
+ queue:
+ name: DotNetCore-Linux
+ timeoutInMinutes: 90
+ parallel: 2
+ matrix:
+ coreclr:
+ _args: --debug
+ _name: CoreClr
+ mono:
+ _args: --debug --docker --mono
+ _name: Mono
+ steps:
+ - script: ./build/scripts/cibuild.sh $(_args)
+ - task: PublishTestResults@1
+ inputs:
+ testRunner: XUnit
+ testResultsFiles: '**/xUnitResults/*.xml'
+ mergeTestResults: true
+ testRunTitle: 'Linux $(_name)'
+ condition: succeededOrFailed()
+
+ - task: PublishBuildArtifacts@1
+ inputs:
+ PathtoPublish: '$(Build.SourcesDirectory)/Binaries/$(_configuration)/Logs'
+ ArtifactName: 'Linux $(_name)'
+ publishLocation: Container
+ continueOnError: true
+ condition: failed()
+
diff --git a/Build.cmd b/Build.cmd
index 5bc7a808e6010..ac384244199b5 100644
--- a/Build.cmd
+++ b/Build.cmd
@@ -1,2 +1,2 @@
@echo off
-powershell -noprofile -executionPolicy RemoteSigned -file "%~dp0\build\scripts\build.ps1" -build -skipBuildExtras %*
+powershell -noprofile -executionPolicy RemoteSigned -file "%~dp0\build\scripts\build.ps1" -build %*
diff --git a/Compilers.sln b/Compilers.sln
index 7edb9b098e407..82c36fb67bfcf 100644
--- a/Compilers.sln
+++ b/Compilers.sln
@@ -2,13 +2,13 @@ Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.27102.0
MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeAnalysisTest", "src\Compilers\Core\CodeAnalysisTest\CodeAnalysisTest.csproj", "{A4C99B85-765C-4C65-9C2A-BB609AAB09E6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.UnitTests", "src\Compilers\Core\CodeAnalysisTest\Microsoft.CodeAnalysis.UnitTests.csproj", "{A4C99B85-765C-4C65-9C2A-BB609AAB09E6}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeAnalysis", "src\Compilers\Core\Portable\CodeAnalysis.csproj", "{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis", "src\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj", "{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VBCSCompiler", "src\Compilers\Server\VBCSCompiler\VBCSCompiler.csproj", "{9508F118-F62E-4C16-A6F4-7C3B56E166AD}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VBCSCompilerTests", "src\Compilers\Server\VBCSCompilerTests\VBCSCompilerTests.csproj", "{F5CE416E-B906-41D2-80B9-0078E887A3F6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VBCSCompiler.UnitTests", "src\Compilers\Server\VBCSCompilerTests\VBCSCompiler.UnitTests.csproj", "{F5CE416E-B906-41D2-80B9-0078E887A3F6}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{A41D1B99-F489-4C43-BBDF-96D61B19A6B9}"
EndProject
@@ -16,41 +16,43 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CSharp", "CSharp", "{32A486
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "csc", "src\Compilers\CSharp\csc\csc.csproj", "{4B45CA0C-03A0-400F-B454-3D4BCB16AF38}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeAnalysis", "src\Compilers\CSharp\Portable\CSharpCodeAnalysis.csproj", "{B501A547-C911-4A05-AC6E-274A50DFF30E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp", "src\Compilers\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.csproj", "{B501A547-C911-4A05-AC6E-274A50DFF30E}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCommandLineTest", "src\Compilers\CSharp\Test\CommandLine\CSharpCommandLineTest.csproj", "{50D26304-0961-4A51-ABF6-6CAD1A56D203}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests", "src\Compilers\CSharp\Test\CommandLine\Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests.csproj", "{50D26304-0961-4A51-ABF6-6CAD1A56D203}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerEmitTest", "src\Compilers\CSharp\Test\Emit\CSharpCompilerEmitTest.csproj", "{4462B57A-7245-4146-B504-D46FDE762948}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Emit.UnitTests", "src\Compilers\CSharp\Test\Emit\Microsoft.CodeAnalysis.CSharp.Emit.UnitTests.csproj", "{4462B57A-7245-4146-B504-D46FDE762948}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerSemanticTest", "src\Compilers\CSharp\Test\Semantic\CSharpCompilerSemanticTest.csproj", "{B2C33A93-DB30-4099-903E-77D75C4C3F45}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests", "src\Compilers\CSharp\Test\IOperation\Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests.csproj", "{1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerSymbolTest", "src\Compilers\CSharp\Test\Symbol\CSharpCompilerSymbolTest.csproj", "{28026D16-EB0C-40B0-BDA7-11CAA2B97CCC}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests", "src\Compilers\CSharp\Test\Semantic\Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests.csproj", "{B2C33A93-DB30-4099-903E-77D75C4C3F45}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerSyntaxTest", "src\Compilers\CSharp\Test\Syntax\CSharpCompilerSyntaxTest.csproj", "{50D26304-0961-4A51-ABF6-6CAD1A56D202}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests", "src\Compilers\CSharp\Test\Symbol\Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests.csproj", "{28026D16-EB0C-40B0-BDA7-11CAA2B97CCC}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests", "src\Compilers\CSharp\Test\Syntax\Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests.csproj", "{50D26304-0961-4A51-ABF6-6CAD1A56D202}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "VisualBasic", "VisualBasic", "{C65C6143-BED3-46E6-869E-9F0BE6E84C37}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CompilerTestResources", "src\Compilers\Test\Resources\Core\CompilerTestResources.csproj", "{7FE6B002-89D8-4298-9B1B-0B5C247DD1FD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Compiler.Test.Resources", "src\Compilers\Test\Resources\Core\Microsoft.CodeAnalysis.Compiler.Test.Resources.csproj", "{7FE6B002-89D8-4298-9B1B-0B5C247DD1FD}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerTestUtilities", "src\Compilers\Test\Utilities\CSharp\CSharpCompilerTestUtilities.csproj", "{4371944A-D3BA-4B5B-8285-82E5FFC6D1F9}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Test.Utilities", "src\Compilers\Test\Utilities\CSharp\Microsoft.CodeAnalysis.CSharp.Test.Utilities.csproj", "{4371944A-D3BA-4B5B-8285-82E5FFC6D1F9}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerTestUtilities", "src\Compilers\Test\Utilities\VisualBasic\BasicCompilerTestUtilities.vbproj", "{4371944A-D3BA-4B5B-8285-82E5FFC6D1F8}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Test.Utilities", "src\Compilers\Test\Utilities\VisualBasic\Microsoft.CodeAnalysis.VisualBasic.Test.Utilities.vbproj", "{4371944A-D3BA-4B5B-8285-82E5FFC6D1F8}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeAnalysis", "src\Compilers\VisualBasic\Portable\BasicCodeAnalysis.vbproj", "{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic", "src\Compilers\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.vbproj", "{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCommandLineTest", "src\Compilers\VisualBasic\Test\CommandLine\BasicCommandLineTest.vbproj", "{E3B32027-3362-41DF-9172-4D3B623F42A5}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests", "src\Compilers\VisualBasic\Test\CommandLine\Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests.vbproj", "{E3B32027-3362-41DF-9172-4D3B623F42A5}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerEmitTest", "src\Compilers\VisualBasic\Test\Emit\BasicCompilerEmitTest.vbproj", "{190CE348-596E-435A-9E5B-12A689F9FC29}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests", "src\Compilers\VisualBasic\Test\Emit\Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests.vbproj", "{190CE348-596E-435A-9E5B-12A689F9FC29}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerIOperationTest", "src\Compilers\VisualBasic\Test\IOperation\BasicCompilerIOperationTest.vbproj", "{9C9DABA4-0E72-4469-ADF1-4991F3CA572A}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Roslyn.Compilers.VisualBasic.IOperation.UnitTests", "src\Compilers\VisualBasic\Test\IOperation\Roslyn.Compilers.VisualBasic.IOperation.UnitTests.vbproj", "{9C9DABA4-0E72-4469-ADF1-4991F3CA572A}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerSemanticTest", "src\Compilers\VisualBasic\Test\Semantic\BasicCompilerSemanticTest.vbproj", "{BF180BD2-4FB7-4252-A7EC-A00E0C7A028A}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests", "src\Compilers\VisualBasic\Test\Semantic\Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests.vbproj", "{BF180BD2-4FB7-4252-A7EC-A00E0C7A028A}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerSymbolTest", "src\Compilers\VisualBasic\Test\Symbol\BasicCompilerSymbolTest.vbproj", "{BDA5D613-596D-4B61-837C-63554151C8F5}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Symbol.UnitTests", "src\Compilers\VisualBasic\Test\Symbol\Microsoft.CodeAnalysis.VisualBasic.Symbol.UnitTests.vbproj", "{BDA5D613-596D-4B61-837C-63554151C8F5}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerSyntaxTest", "src\Compilers\VisualBasic\Test\Syntax\BasicCompilerSyntaxTest.vbproj", "{91F6F646-4F6E-449A-9AB4-2986348F329D}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests", "src\Compilers\VisualBasic\Test\Syntax\Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests.vbproj", "{91F6F646-4F6E-449A-9AB4-2986348F329D}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PdbUtilities", "src\Test\PdbUtilities\PdbUtilities.csproj", "{AFDE6BEA-5038-4A4A-A88E-DBD2E4088EED}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Test.PdbUtilities", "src\Test\PdbUtilities\Roslyn.Test.PdbUtilities.csproj", "{AFDE6BEA-5038-4A4A-A88E-DBD2E4088EED}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tools", "Tools", "{FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}"
EndProject
@@ -66,11 +68,11 @@ Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "VisualBasicErrorFactsGenera
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "AnalyzerDriver", "src\Compilers\Core\AnalyzerDriver\AnalyzerDriver.shproj", "{D0BC9BE7-24F6-40CA-8DC6-FCB93BD44B34}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpWinRTTest", "src\Compilers\CSharp\Test\WinRT\CSharpWinRTTest.csproj", "{FCFA8808-A1B6-48CC-A1EA-0B8CA8AEDA8E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests", "src\Compilers\CSharp\Test\WinRT\Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests.csproj", "{FCFA8808-A1B6-48CC-A1EA-0B8CA8AEDA8E}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "vbc", "src\Compilers\VisualBasic\vbc\vbc.csproj", "{E58EE9D7-1239-4961-A0C1-F9EC3952C4C1}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MSBuildTaskTests", "src\Compilers\Core\MSBuildTaskTests\MSBuildTaskTests.csproj", "{1DFEA9C5-973C-4179-9B1B-0F32288E1EF2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Build.Tasks.CodeAnalysis.UnitTests", "src\Compilers\Core\MSBuildTaskTests\Microsoft.Build.Tasks.CodeAnalysis.UnitTests.csproj", "{1DFEA9C5-973C-4179-9B1B-0F32288E1EF2}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Server", "Server", "{E35DA3D1-16C0-4318-9187-6B664F12A870}"
EndProject
@@ -80,7 +82,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Test", "Test", "{6F016299-B
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RunTests", "src\Tools\Source\RunTests\RunTests.csproj", "{1A3941F1-1E1F-4EF7-8064-7729C4C2E2AA}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "src\Test\Utilities\Portable\TestUtilities.csproj", "{CCBD3438-3E84-40A9-83AD-533F23BCFCA5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Test.Utilities", "src\Test\Utilities\Portable\Roslyn.Test.Utilities.csproj", "{CCBD3438-3E84-40A9-83AD-533F23BCFCA5}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Dependencies", "Dependencies", "{3CDEA9FB-CD44-4AB4-98A8-5537AAA2169B}"
EndProject
@@ -88,63 +90,73 @@ Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Microsoft.CodeAnalysis.Pool
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Microsoft.CodeAnalysis.Debugging", "src\Dependencies\CodeAnalysis.Debugging\Microsoft.CodeAnalysis.Debugging.shproj", "{D73ADF7D-2C1C-42AE-B2AB-EDC9497E4B71}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MSBuildTask", "src\Compilers\Core\MSBuildTask\MSBuildTask.csproj", "{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Build.Tasks.CodeAnalysis", "src\Compilers\Core\MSBuildTask\Microsoft.Build.Tasks.CodeAnalysis.csproj", "{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ScriptingTest", "src\Scripting\CoreTest\ScriptingTest.csproj", "{2DAE4406-7A89-4B5F-95C3-BC5472CE47CE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting.UnitTests", "src\Scripting\CoreTest\Microsoft.CodeAnalysis.Scripting.UnitTests.csproj", "{2DAE4406-7A89-4B5F-95C3-BC5472CE47CE}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpScriptingTest", "src\Scripting\CSharpTest\CSharpScriptingTest.csproj", "{2DAE4406-7A89-4B5F-95C3-BC5422CE47CE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests", "src\Scripting\CSharpTest\Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests.csproj", "{2DAE4406-7A89-4B5F-95C3-BC5422CE47CE}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicScriptingTest", "src\Scripting\VisualBasicTest\BasicScriptingTest.vbproj", "{ABC7262E-1053-49F3-B846-E3091BB92E8C}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests", "src\Scripting\VisualBasicTest\Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests.vbproj", "{ABC7262E-1053-49F3-B846-E3091BB92E8C}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Scripting", "Scripting", "{3FF38FD4-DF16-44B0-924F-0D5AE155495B}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Scripting", "src\Scripting\Core\Scripting.csproj", "{12A68549-4E8C-42D6-8703-A09335F97997}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpScripting", "src\Scripting\CSharp\CSharpScripting.csproj", "{066F0DBD-C46C-4C20-AFEC-99829A172625}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting", "src\Scripting\Core\Microsoft.CodeAnalysis.Scripting.csproj", "{12A68549-4E8C-42D6-8703-A09335F97997}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicScripting", "src\Scripting\VisualBasic\BasicScripting.vbproj", "{3E7DEA65-317B-4F43-A25D-62F18D96CFD7}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Scripting", "src\Scripting\CSharp\Microsoft.CodeAnalysis.CSharp.Scripting.csproj", "{066F0DBD-C46C-4C20-AFEC-99829A172625}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ScriptingTestUtilities", "src\Scripting\CoreTestUtilities\ScriptingTestUtilities.csproj", "{21A01C2D-2501-4619-8144-48977DD22D9C}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Scripting", "src\Scripting\VisualBasic\Microsoft.CodeAnalysis.VisualBasic.Scripting.vbproj", "{3E7DEA65-317B-4F43-A25D-62F18D96CFD7}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Toolset", "build\Toolset\Toolset.csproj", "{57557F32-0635-421A-BCF8-549AED50F764}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting.TestUtilities", "src\Scripting\CoreTestUtilities\Microsoft.CodeAnalysis.Scripting.TestUtilities.csproj", "{21A01C2D-2501-4619-8144-48977DD22D9C}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "csi", "src\Interactive\csi\csi.csproj", "{14118347-ED06-4608-9C45-18228273C712}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Workspace", "Workspace", "{D9591377-7868-4D64-9314-83E0C92A871B}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Workspaces", "src\Workspaces\Core\Portable\Workspaces.csproj", "{5F8D2414-064A-4B3A-9B42-8E2A04246BE5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Workspaces", "src\Workspaces\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj", "{5F8D2414-064A-4B3A-9B42-8E2A04246BE5}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpWorkspace", "src\Workspaces\CSharp\Portable\CSharpWorkspace.csproj", "{21B239D0-D144-430F-A394-C066D58EE267}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Workspaces", "src\Workspaces\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.Workspaces.csproj", "{21B239D0-D144-430F-A394-C066D58EE267}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicWorkspace", "src\Workspaces\VisualBasic\Portable\BasicWorkspace.vbproj", "{57CA988D-F010-4BF2-9A2E-07D6DCD2FF2C}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Workspaces", "src\Workspaces\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj", "{57CA988D-F010-4BF2-9A2E-07D6DCD2FF2C}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CodeStyle", "CodeStyle", "{B20208C3-D3A6-4020-A274-6BE3786D29FB}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeStyle", "src\CodeStyle\Core\Analyzers\CodeStyle.csproj", "{275812EE-DEDB-4232-9439-91C9757D2AE4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CodeStyle", "src\CodeStyle\Core\Analyzers\Microsoft.CodeAnalysis.CodeStyle.csproj", "{275812EE-DEDB-4232-9439-91C9757D2AE4}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeStyleFixes", "src\CodeStyle\Core\CodeFixes\CodeStyleFixes.csproj", "{5FF1E493-69CC-4D0B-83F2-039F469A04E1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CodeStyle.Fixes", "src\CodeStyle\Core\CodeFixes\Microsoft.CodeAnalysis.CodeStyle.Fixes.csproj", "{5FF1E493-69CC-4D0B-83F2-039F469A04E1}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeStyleTests", "src\CodeStyle\Core\Tests\CodeStyleTests.csproj", "{9FF1205F-1D7C-4EE4-B038-3456FE6EBEAF}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CodeStyle.UnitTests", "src\CodeStyle\Core\Tests\Microsoft.CodeAnalysis.CodeStyle.UnitTests.csproj", "{9FF1205F-1D7C-4EE4-B038-3456FE6EBEAF}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeStyle", "src\CodeStyle\CSharp\Analyzers\CSharpCodeStyle.csproj", "{AA87BFED-089A-4096-B8D5-690BDC7D5B24}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.CodeStyle", "src\CodeStyle\CSharp\Analyzers\Microsoft.CodeAnalysis.CSharp.CodeStyle.csproj", "{AA87BFED-089A-4096-B8D5-690BDC7D5B24}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeStyleFixes", "src\CodeStyle\CSharp\CodeFixes\CSharpCodeStyleFixes.csproj", "{A07ABCF5-BC43-4EE9-8FD8-B2D77FD54D73}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes", "src\CodeStyle\CSharp\CodeFixes\Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes.csproj", "{A07ABCF5-BC43-4EE9-8FD8-B2D77FD54D73}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeStyleTests", "src\CodeStyle\CSharp\Tests\CSharpCodeStyleTests.csproj", "{5018D049-5870-465A-889B-C742CE1E31CB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests", "src\CodeStyle\CSharp\Tests\Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests.csproj", "{5018D049-5870-465A-889B-C742CE1E31CB}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeStyle", "src\CodeStyle\VisualBasic\Analyzers\BasicCodeStyle.vbproj", "{2531A8C4-97DD-47BC-A79C-B7846051E137}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.CodeStyle", "src\CodeStyle\VisualBasic\Analyzers\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.vbproj", "{2531A8C4-97DD-47BC-A79C-B7846051E137}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeStyleFixes", "src\CodeStyle\VisualBasic\CodeFixes\BasicCodeStyleFixes.vbproj", "{0141285D-8F6C-42C7-BAF3-3C0CCD61C716}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes", "src\CodeStyle\VisualBasic\CodeFixes\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes.vbproj", "{0141285D-8F6C-42C7-BAF3-3C0CCD61C716}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeStyleTests", "src\CodeStyle\VisualBasic\Tests\BasicCodeStyleTests.vbproj", "{E512C6C1-F085-4AD7-B0D9-E8F1A0A2A510}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.CodeStyle.UnitTests", "src\CodeStyle\VisualBasic\Tests\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.UnitTests.vbproj", "{E512C6C1-F085-4AD7-B0D9-E8F1A0A2A510}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "CSharpAnalyzerDriver", "src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpAnalyzerDriver.shproj", "{54E08BF5-F819-404F-A18D-0AB9EA81EA04}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "BasicAnalyzerDriver", "src\Compilers\VisualBasic\BasicAnalyzerDriver\BasicAnalyzerDriver.shproj", "{E8F0BAA5-7327-43D1-9A51-644E81AE55F1}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ILAsm", "src\Tools\ILAsm\ILAsm.csproj", "{46B3E63A-C462-4133-9F27-3B85DA5E7D37}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IlAsmDeploy", "src\Tools\ILAsm\IlAsmDeploy.csproj", "{46B3E63A-C462-4133-9F27-3B85DA5E7D37}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Packages", "Packages", "{274B96B7-F815-47E3-9CA4-4024A57A478F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.NETCore.Compilers.Package", "src\NuGet\Microsoft.NETCore.Compilers\Microsoft.NETCore.Compilers.Package.csproj", "{15FEBD1B-55CE-4EBD-85E3-04898260A25B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Net.Compilers.Package", "src\NuGet\Microsoft.Net.Compilers\Microsoft.Net.Compilers.Package.csproj", "{27B1EAE2-2E06-48EF-8A67-06D6FB3DC275}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Compilers.Package", "src\NuGet\Microsoft.CodeAnalysis.Compilers.Package.csproj", "{E0756C89-603F-4B48-8E64-1D53E62654C8}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting.Package", "src\NuGet\Microsoft.CodeAnalysis.Scripting.Package.csproj", "{7F8057D9-F70F-4EA7-BD64-AB2D0DD8057B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Package", "src\NuGet\Microsoft.CodeAnalysis.Package.csproj", "{2483917E-7024-4D10-99C6-2BEF338FF53B}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NuGetProjectPackUtil", "src\NuGet\NuGetProjectPackUtil.csproj", "{B2B261E8-56EC-45DC-8AB8-A491A065EFD4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CompilerBenchmarks", "src\Tools\CompilerBenchmarks\CompilerBenchmarks.csproj", "{B446E771-AB52-41C9-ACFC-FDF8EACAF291}"
EndProject
Global
GlobalSection(SharedMSBuildProjectFiles) = preSolution
@@ -205,6 +217,10 @@ Global
{4462B57A-7245-4146-B504-D46FDE762948}.Debug|Any CPU.Build.0 = Debug|Any CPU
{4462B57A-7245-4146-B504-D46FDE762948}.Release|Any CPU.ActiveCfg = Release|Any CPU
{4462B57A-7245-4146-B504-D46FDE762948}.Release|Any CPU.Build.0 = Release|Any CPU
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}.Release|Any CPU.Build.0 = Release|Any CPU
{B2C33A93-DB30-4099-903E-77D75C4C3F45}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{B2C33A93-DB30-4099-903E-77D75C4C3F45}.Debug|Any CPU.Build.0 = Debug|Any CPU
{B2C33A93-DB30-4099-903E-77D75C4C3F45}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -333,10 +349,6 @@ Global
{21A01C2D-2501-4619-8144-48977DD22D9C}.Debug|Any CPU.Build.0 = Debug|Any CPU
{21A01C2D-2501-4619-8144-48977DD22D9C}.Release|Any CPU.ActiveCfg = Release|Any CPU
{21A01C2D-2501-4619-8144-48977DD22D9C}.Release|Any CPU.Build.0 = Release|Any CPU
- {57557F32-0635-421A-BCF8-549AED50F764}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
- {57557F32-0635-421A-BCF8-549AED50F764}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {57557F32-0635-421A-BCF8-549AED50F764}.Release|Any CPU.ActiveCfg = Release|Any CPU
- {57557F32-0635-421A-BCF8-549AED50F764}.Release|Any CPU.Build.0 = Release|Any CPU
{14118347-ED06-4608-9C45-18228273C712}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{14118347-ED06-4608-9C45-18228273C712}.Debug|Any CPU.Build.0 = Debug|Any CPU
{14118347-ED06-4608-9C45-18228273C712}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -393,10 +405,30 @@ Global
{46B3E63A-C462-4133-9F27-3B85DA5E7D37}.Debug|Any CPU.Build.0 = Debug|Any CPU
{46B3E63A-C462-4133-9F27-3B85DA5E7D37}.Release|Any CPU.ActiveCfg = Release|Any CPU
{46B3E63A-C462-4133-9F27-3B85DA5E7D37}.Release|Any CPU.Build.0 = Release|Any CPU
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4}.Release|Any CPU.ActiveCfg = Release|Any CPU
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4}.Release|Any CPU.Build.0 = Release|Any CPU
+ {B446E771-AB52-41C9-ACFC-FDF8EACAF291}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {B446E771-AB52-41C9-ACFC-FDF8EACAF291}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {B446E771-AB52-41C9-ACFC-FDF8EACAF291}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {B446E771-AB52-41C9-ACFC-FDF8EACAF291}.Release|Any CPU.Build.0 = Release|Any CPU
+ {15FEBD1B-55CE-4EBD-85E3-04898260A25B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {15FEBD1B-55CE-4EBD-85E3-04898260A25B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {15FEBD1B-55CE-4EBD-85E3-04898260A25B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {15FEBD1B-55CE-4EBD-85E3-04898260A25B}.Release|Any CPU.Build.0 = Release|Any CPU
+ {27B1EAE2-2E06-48EF-8A67-06D6FB3DC275}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {27B1EAE2-2E06-48EF-8A67-06D6FB3DC275}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {27B1EAE2-2E06-48EF-8A67-06D6FB3DC275}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {27B1EAE2-2E06-48EF-8A67-06D6FB3DC275}.Release|Any CPU.Build.0 = Release|Any CPU
+ {E0756C89-603F-4B48-8E64-1D53E62654C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {E0756C89-603F-4B48-8E64-1D53E62654C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {E0756C89-603F-4B48-8E64-1D53E62654C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {E0756C89-603F-4B48-8E64-1D53E62654C8}.Release|Any CPU.Build.0 = Release|Any CPU
+ {7F8057D9-F70F-4EA7-BD64-AB2D0DD8057B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {7F8057D9-F70F-4EA7-BD64-AB2D0DD8057B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {7F8057D9-F70F-4EA7-BD64-AB2D0DD8057B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {7F8057D9-F70F-4EA7-BD64-AB2D0DD8057B}.Release|Any CPU.Build.0 = Release|Any CPU
+ {2483917E-7024-4D10-99C6-2BEF338FF53B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {2483917E-7024-4D10-99C6-2BEF338FF53B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {2483917E-7024-4D10-99C6-2BEF338FF53B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {2483917E-7024-4D10-99C6-2BEF338FF53B}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
@@ -410,6 +442,7 @@ Global
{B501A547-C911-4A05-AC6E-274A50DFF30E} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{50D26304-0961-4A51-ABF6-6CAD1A56D203} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{4462B57A-7245-4146-B504-D46FDE762948} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{B2C33A93-DB30-4099-903E-77D75C4C3F45} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{28026D16-EB0C-40B0-BDA7-11CAA2B97CCC} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{50D26304-0961-4A51-ABF6-6CAD1A56D202} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
@@ -446,7 +479,6 @@ Global
{066F0DBD-C46C-4C20-AFEC-99829A172625} = {3FF38FD4-DF16-44B0-924F-0D5AE155495B}
{3E7DEA65-317B-4F43-A25D-62F18D96CFD7} = {3FF38FD4-DF16-44B0-924F-0D5AE155495B}
{21A01C2D-2501-4619-8144-48977DD22D9C} = {3FF38FD4-DF16-44B0-924F-0D5AE155495B}
- {57557F32-0635-421A-BCF8-549AED50F764} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
{14118347-ED06-4608-9C45-18228273C712} = {3FF38FD4-DF16-44B0-924F-0D5AE155495B}
{5F8D2414-064A-4B3A-9B42-8E2A04246BE5} = {D9591377-7868-4D64-9314-83E0C92A871B}
{21B239D0-D144-430F-A394-C066D58EE267} = {D9591377-7868-4D64-9314-83E0C92A871B}
@@ -463,7 +495,12 @@ Global
{54E08BF5-F819-404F-A18D-0AB9EA81EA04} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{E8F0BAA5-7327-43D1-9A51-644E81AE55F1} = {C65C6143-BED3-46E6-869E-9F0BE6E84C37}
{46B3E63A-C462-4133-9F27-3B85DA5E7D37} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
+ {B446E771-AB52-41C9-ACFC-FDF8EACAF291} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
+ {15FEBD1B-55CE-4EBD-85E3-04898260A25B} = {274B96B7-F815-47E3-9CA4-4024A57A478F}
+ {27B1EAE2-2E06-48EF-8A67-06D6FB3DC275} = {274B96B7-F815-47E3-9CA4-4024A57A478F}
+ {E0756C89-603F-4B48-8E64-1D53E62654C8} = {274B96B7-F815-47E3-9CA4-4024A57A478F}
+ {7F8057D9-F70F-4EA7-BD64-AB2D0DD8057B} = {3FF38FD4-DF16-44B0-924F-0D5AE155495B}
+ {2483917E-7024-4D10-99C6-2BEF338FF53B} = {274B96B7-F815-47E3-9CA4-4024A57A478F}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {6F599E08-A9EA-4FAA-897F-5D824B0210E6}
diff --git a/README.md b/README.md
index cb6e8b06aa95d..a8aaad6499650 100644
--- a/README.md
+++ b/README.md
@@ -9,8 +9,11 @@
|**master-vs-deps**|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_debug_unit32/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_debug_unit64/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_release_unit32/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_release_unit64/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/master-vs-deps/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/master-vs-deps/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/master-vs-deps/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/windows_debug_spanish_unit32_prtest/)
|**dev15.7.x**|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x/windows_debug_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x/windows_debug_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x/windows_release_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x/windows_release_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/windows_debug_spanish_unit32_prtest/)
|**dev15.7.x-vs-deps**|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x-vs-deps/windows_debug_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x-vs-deps/windows_debug_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x-vs-deps/windows_release_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x-vs-deps/windows_release_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x-vs-deps/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x-vs-deps/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.7.x-vs-deps/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/windows_debug_spanish_unit32_prtest/)
-|**dev15.8-preview3**|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3/windows_debug_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3/windows_debug_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3/windows_release_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3/windows_release_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/windows_debug_spanish_unit32_prtest/)
-|**dev15.8-preview3-vs-deps**|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3-vs-deps/windows_debug_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3-vs-deps/windows_debug_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3-vs-deps/windows_release_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3-vs-deps/windows_release_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3-vs-deps/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3-vs-deps/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8-preview3-vs-deps/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/windows_debug_spanish_unit32_prtest/)
+|**dev15.8.x**|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x/windows_debug_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x/windows_debug_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x/windows_release_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x/windows_release_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/windows_debug_spanish_unit32_prtest/)
+|**dev15.8-vs-deps**|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x-vs-deps/windows_debug_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x/windows_debug_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x-vs-deps/windows_release_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x-vs-deps/windows_release_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x-vs-deps/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x-vs-deps/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.8.x-vs-deps/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/windows_debug_spanish_unit32_prtest/)
+|**dev15.9.x**|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x/windows_debug_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x/windows_debug_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x/windows_release_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x/windows_release_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/windows_debug_spanish_unit32_prtest/)
+|**dev15.9-vs-deps**|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x-vs-deps/windows_debug_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_debug_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x/windows_debug_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_debug_unit64/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x-vs-deps/windows_release_unit32)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_release_unit32/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x-vs-deps/windows_release_unit64)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_release_unit64/)|[![Build Status](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_determinism/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_determinism/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x-vs-deps/windows_debug_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_debug_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x-vs-deps/windows_release_vs-integration)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_release_vs-integration/)|[![Build Status](https://ci.dot.net/buildStatus/icon?job=dotnet_roslyn/dev15.9.x-vs-deps/windows_debug_spanish_unit32_prtest)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/windows_debug_spanish_unit32_prtest/)
+
### Linux/Mac - Unit Tests
|Branch|Ubuntu16|macOS|
@@ -19,8 +22,10 @@
|**master-vs-deps**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/master-vs-deps/job/mac_debug/)|e/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.6.x/job/mac_debug/)|
|**dev15.7.x**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x/job/mac_debug/)|
|**dev15.7.x-vs-deps**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.7.x-vs-deps/job/mac_debug/)|
-|**dev15.8-preview3**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3/job/mac_debug/)|
-|**dev15.8-preview3-vs-deps**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8-preview3-vs-deps/job/mac_debug/)|
+|**dev15.8.x**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x/job/mac_debug/)|
+|**dev15.8.x-vs-deps**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.8.x-vs-deps/job/mac_debug/)|
+|**dev15.9.x**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x/job/mac_debug/)|
+|**dev15.9.x-vs-deps**|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/ubuntu_16_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/ubuntu_16_debug/)|[![BuildStatus](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/mac_debug/badge/icon)](https://ci.dot.net/job/dotnet_roslyn/job/dev15.9.x-vs-deps/job/mac_debug/)|
[//]: # (End current test results)
@@ -94,4 +99,4 @@ This project has adopted the [Microsoft Open Source Code of Conduct](https://ope
### .NET Foundation
This project is part of the [.NET Foundation](http://www.dotnetfoundation.org/projects) along with other
-projects like [the class libraries for .NET Core](https://github.com/dotnet/corefx/).
+projects like [the class libraries for .NET Core](https://github.com/dotnet/corefx/).
\ No newline at end of file
diff --git a/Roslyn.sln b/Roslyn.sln
index e2af5cab8bb73..8d974d864cf39 100644
--- a/Roslyn.sln
+++ b/Roslyn.sln
@@ -2,7 +2,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.27110.0
MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn", "src\Deployment\Roslyn.csproj", "{600AF682-E097-407B-AD85-EE3CED37E680}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RoslynDeployment", "src\Deployment\RoslynDeployment.csproj", "{600AF682-E097-407B-AD85-EE3CED37E680}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{A41D1B99-F489-4C43-BBDF-96D61B19A6B9}"
EndProject
@@ -59,51 +59,53 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Perf", "Perf", "{DD13507E-D
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CodeStyle", "CodeStyle", "{DC014586-8D07-4DE6-B28E-C0540C59C085}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeAnalysisTest", "src\Compilers\Core\CodeAnalysisTest\CodeAnalysisTest.csproj", "{A4C99B85-765C-4C65-9C2A-BB609AAB09E6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.UnitTests", "src\Compilers\Core\CodeAnalysisTest\Microsoft.CodeAnalysis.UnitTests.csproj", "{A4C99B85-765C-4C65-9C2A-BB609AAB09E6}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeAnalysis", "src\Compilers\Core\Portable\CodeAnalysis.csproj", "{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis", "src\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj", "{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VBCSCompiler", "src\Compilers\Server\VBCSCompiler\VBCSCompiler.csproj", "{9508F118-F62E-4C16-A6F4-7C3B56E166AD}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VBCSCompilerTests", "src\Compilers\Server\VBCSCompilerTests\VBCSCompilerTests.csproj", "{F5CE416E-B906-41D2-80B9-0078E887A3F6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VBCSCompiler.UnitTests", "src\Compilers\Server\VBCSCompilerTests\VBCSCompiler.UnitTests.csproj", "{F5CE416E-B906-41D2-80B9-0078E887A3F6}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "csc", "src\Compilers\CSharp\csc\csc.csproj", "{4B45CA0C-03A0-400F-B454-3D4BCB16AF38}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeAnalysis", "src\Compilers\CSharp\Portable\CSharpCodeAnalysis.csproj", "{B501A547-C911-4A05-AC6E-274A50DFF30E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp", "src\Compilers\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.csproj", "{B501A547-C911-4A05-AC6E-274A50DFF30E}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCommandLineTest", "src\Compilers\CSharp\Test\CommandLine\CSharpCommandLineTest.csproj", "{50D26304-0961-4A51-ABF6-6CAD1A56D203}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests", "src\Compilers\CSharp\Test\CommandLine\Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests.csproj", "{50D26304-0961-4A51-ABF6-6CAD1A56D203}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerEmitTest", "src\Compilers\CSharp\Test\Emit\CSharpCompilerEmitTest.csproj", "{4462B57A-7245-4146-B504-D46FDE762948}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Emit.UnitTests", "src\Compilers\CSharp\Test\Emit\Microsoft.CodeAnalysis.CSharp.Emit.UnitTests.csproj", "{4462B57A-7245-4146-B504-D46FDE762948}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerSemanticTest", "src\Compilers\CSharp\Test\Semantic\CSharpCompilerSemanticTest.csproj", "{B2C33A93-DB30-4099-903E-77D75C4C3F45}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests", "src\Compilers\CSharp\Test\IOperation\Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests.csproj", "{1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerSymbolTest", "src\Compilers\CSharp\Test\Symbol\CSharpCompilerSymbolTest.csproj", "{28026D16-EB0C-40B0-BDA7-11CAA2B97CCC}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests", "src\Compilers\CSharp\Test\Semantic\Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests.csproj", "{B2C33A93-DB30-4099-903E-77D75C4C3F45}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerSyntaxTest", "src\Compilers\CSharp\Test\Syntax\CSharpCompilerSyntaxTest.csproj", "{50D26304-0961-4A51-ABF6-6CAD1A56D202}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests", "src\Compilers\CSharp\Test\Symbol\Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests.csproj", "{28026D16-EB0C-40B0-BDA7-11CAA2B97CCC}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CompilerTestResources", "src\Compilers\Test\Resources\Core\CompilerTestResources.csproj", "{7FE6B002-89D8-4298-9B1B-0B5C247DD1FD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests", "src\Compilers\CSharp\Test\Syntax\Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests.csproj", "{50D26304-0961-4A51-ABF6-6CAD1A56D202}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCompilerTestUtilities", "src\Compilers\Test\Utilities\CSharp\CSharpCompilerTestUtilities.csproj", "{4371944A-D3BA-4B5B-8285-82E5FFC6D1F9}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Compiler.Test.Resources", "src\Compilers\Test\Resources\Core\Microsoft.CodeAnalysis.Compiler.Test.Resources.csproj", "{7FE6B002-89D8-4298-9B1B-0B5C247DD1FD}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerTestUtilities", "src\Compilers\Test\Utilities\VisualBasic\BasicCompilerTestUtilities.vbproj", "{4371944A-D3BA-4B5B-8285-82E5FFC6D1F8}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Test.Utilities", "src\Compilers\Test\Utilities\CSharp\Microsoft.CodeAnalysis.CSharp.Test.Utilities.csproj", "{4371944A-D3BA-4B5B-8285-82E5FFC6D1F9}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeAnalysis", "src\Compilers\VisualBasic\Portable\BasicCodeAnalysis.vbproj", "{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Test.Utilities", "src\Compilers\Test\Utilities\VisualBasic\Microsoft.CodeAnalysis.VisualBasic.Test.Utilities.vbproj", "{4371944A-D3BA-4B5B-8285-82E5FFC6D1F8}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCommandLineTest", "src\Compilers\VisualBasic\Test\CommandLine\BasicCommandLineTest.vbproj", "{E3B32027-3362-41DF-9172-4D3B623F42A5}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic", "src\Compilers\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.vbproj", "{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerEmitTest", "src\Compilers\VisualBasic\Test\Emit\BasicCompilerEmitTest.vbproj", "{190CE348-596E-435A-9E5B-12A689F9FC29}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests", "src\Compilers\VisualBasic\Test\CommandLine\Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests.vbproj", "{E3B32027-3362-41DF-9172-4D3B623F42A5}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerIOperationTest", "src\Compilers\VisualBasic\Test\IOperation\BasicCompilerIOperationTest.vbproj", "{9C9DABA4-0E72-4469-ADF1-4991F3CA572A}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests", "src\Compilers\VisualBasic\Test\Emit\Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests.vbproj", "{190CE348-596E-435A-9E5B-12A689F9FC29}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerSemanticTest", "src\Compilers\VisualBasic\Test\Semantic\BasicCompilerSemanticTest.vbproj", "{BF180BD2-4FB7-4252-A7EC-A00E0C7A028A}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Roslyn.Compilers.VisualBasic.IOperation.UnitTests", "src\Compilers\VisualBasic\Test\IOperation\Roslyn.Compilers.VisualBasic.IOperation.UnitTests.vbproj", "{9C9DABA4-0E72-4469-ADF1-4991F3CA572A}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerSymbolTest", "src\Compilers\VisualBasic\Test\Symbol\BasicCompilerSymbolTest.vbproj", "{BDA5D613-596D-4B61-837C-63554151C8F5}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests", "src\Compilers\VisualBasic\Test\Semantic\Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests.vbproj", "{BF180BD2-4FB7-4252-A7EC-A00E0C7A028A}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCompilerSyntaxTest", "src\Compilers\VisualBasic\Test\Syntax\BasicCompilerSyntaxTest.vbproj", "{91F6F646-4F6E-449A-9AB4-2986348F329D}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Symbol.UnitTests", "src\Compilers\VisualBasic\Test\Symbol\Microsoft.CodeAnalysis.VisualBasic.Symbol.UnitTests.vbproj", "{BDA5D613-596D-4B61-837C-63554151C8F5}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PdbUtilities", "src\Test\PdbUtilities\PdbUtilities.csproj", "{AFDE6BEA-5038-4A4A-A88E-DBD2E4088EED}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests", "src\Compilers\VisualBasic\Test\Syntax\Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests.vbproj", "{91F6F646-4F6E-449A-9AB4-2986348F329D}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Workspaces", "src\Workspaces\Core\Portable\Workspaces.csproj", "{5F8D2414-064A-4B3A-9B42-8E2A04246BE5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Test.PdbUtilities", "src\Test\PdbUtilities\Roslyn.Test.PdbUtilities.csproj", "{AFDE6BEA-5038-4A4A-A88E-DBD2E4088EED}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Workspaces", "src\Workspaces\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj", "{5F8D2414-064A-4B3A-9B42-8E2A04246BE5}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CompilersBoundTreeGenerator", "src\Tools\Source\CompilerGeneratorTools\Source\BoundTreeGenerator\CompilersBoundTreeGenerator.csproj", "{02459936-CD2C-4F61-B671-5C518F2A3DDC}"
EndProject
@@ -113,159 +115,159 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpSyntaxGenerator", "sr
EndProject
Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "VisualBasicSyntaxGenerator", "src\Tools\Source\CompilerGeneratorTools\Source\VisualBasicSyntaxGenerator\VisualBasicSyntaxGenerator.vbproj", "{6AA96934-D6B7-4CC8-990D-DB6B9DD56E34}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ServicesTest", "src\Workspaces\CoreTest\ServicesTest.csproj", "{C50166F1-BABC-40A9-95EB-8200080CD701}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Workspaces.UnitTests", "src\Workspaces\CoreTest\Microsoft.CodeAnalysis.Workspaces.UnitTests.csproj", "{C50166F1-BABC-40A9-95EB-8200080CD701}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpServicesTest", "src\Workspaces\CSharpTest\CSharpServicesTest.csproj", "{E195A63F-B5A4-4C5A-96BD-8E7ED6A181B7}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests", "src\Workspaces\CSharpTest\Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests.csproj", "{E195A63F-B5A4-4C5A-96BD-8E7ED6A181B7}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "VisualBasicServicesTest", "src\Workspaces\VisualBasicTest\VisualBasicServicesTest.vbproj", "{E3FDC65F-568D-4E2D-A093-5132FD3793B7}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests", "src\Workspaces\VisualBasicTest\Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests.vbproj", "{E3FDC65F-568D-4E2D-A093-5132FD3793B7}"
EndProject
Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "VisualBasicErrorFactsGenerator", "src\Tools\Source\CompilerGeneratorTools\Source\VisualBasicErrorFactsGenerator\VisualBasicErrorFactsGenerator.vbproj", "{909B656F-6095-4AC2-A5AB-C3F032315C45}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Workspaces.Desktop", "src\Workspaces\Core\Desktop\Workspaces.Desktop.csproj", "{2E87FA96-50BB-4607-8676-46521599F998}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Workspaces.Desktop", "src\Workspaces\Core\Desktop\Microsoft.CodeAnalysis.Workspaces.Desktop.csproj", "{2E87FA96-50BB-4607-8676-46521599F998}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Workspaces.MSBuild", "src\Workspaces\Core\MSBuild\Workspaces.MSBuild.csproj", "{96EB2D3B-F694-48C6-A284-67382841E086}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Workspaces.MSBuild", "src\Workspaces\Core\MSBuild\Microsoft.CodeAnalysis.Workspaces.MSBuild.csproj", "{96EB2D3B-F694-48C6-A284-67382841E086}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpWorkspace", "src\Workspaces\CSharp\Portable\CSharpWorkspace.csproj", "{21B239D0-D144-430F-A394-C066D58EE267}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Workspaces", "src\Workspaces\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.Workspaces.csproj", "{21B239D0-D144-430F-A394-C066D58EE267}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicWorkspace", "src\Workspaces\VisualBasic\Portable\BasicWorkspace.vbproj", "{57CA988D-F010-4BF2-9A2E-07D6DCD2FF2C}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Workspaces", "src\Workspaces\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj", "{57CA988D-F010-4BF2-9A2E-07D6DCD2FF2C}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RunTests", "src\Tools\Source\RunTests\RunTests.csproj", "{1A3941F1-1E1F-4EF7-8064-7729C4C2E2AA}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicFeatures", "src\Features\VisualBasic\Portable\BasicFeatures.vbproj", "{A1BCD0CE-6C2F-4F8C-9A48-D9D93928E26D}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Features", "src\Features\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.Features.vbproj", "{A1BCD0CE-6C2F-4F8C-9A48-D9D93928E26D}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpFeatures", "src\Features\CSharp\Portable\CSharpFeatures.csproj", "{3973B09A-4FBF-44A5-8359-3D22CEB71F71}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Features", "src\Features\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.Features.csproj", "{3973B09A-4FBF-44A5-8359-3D22CEB71F71}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Features", "src\Features\Core\Portable\Features.csproj", "{EDC68A0E-C68D-4A74-91B7-BF38EC909888}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Features", "src\Features\Core\Portable\Microsoft.CodeAnalysis.Features.csproj", "{EDC68A0E-C68D-4A74-91B7-BF38EC909888}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TextEditorFeatures", "src\EditorFeatures\Text\TextEditorFeatures.csproj", "{18F5FBB8-7570-4412-8CC7-0A86FF13B7BA}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.EditorFeatures.Text", "src\EditorFeatures\Text\Microsoft.CodeAnalysis.EditorFeatures.Text.csproj", "{18F5FBB8-7570-4412-8CC7-0A86FF13B7BA}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicEditorFeatures", "src\EditorFeatures\VisualBasic\BasicEditorFeatures.vbproj", "{49BFAE50-1BCE-48AE-BC89-78B7D90A3ECD}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.EditorFeatures", "src\EditorFeatures\VisualBasic\Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.vbproj", "{49BFAE50-1BCE-48AE-BC89-78B7D90A3ECD}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpEditorFeatures", "src\EditorFeatures\CSharp\CSharpEditorFeatures.csproj", "{B0CE9307-FFDB-4838-A5EC-CE1F7CDC4AC2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.EditorFeatures", "src\EditorFeatures\CSharp\Microsoft.CodeAnalysis.CSharp.EditorFeatures.csproj", "{B0CE9307-FFDB-4838-A5EC-CE1F7CDC4AC2}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EditorFeatures", "src\EditorFeatures\Core\EditorFeatures.csproj", "{3CDEEAB7-2256-418A-BEB2-620B5CB16302}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.EditorFeatures", "src\EditorFeatures\Core\Microsoft.CodeAnalysis.EditorFeatures.csproj", "{3CDEEAB7-2256-418A-BEB2-620B5CB16302}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicEditorServicesTest", "src\EditorFeatures\VisualBasicTest\BasicEditorServicesTest.vbproj", "{0BE66736-CDAA-4989-88B1-B3F46EBDCA4A}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.UnitTests", "src\EditorFeatures\VisualBasicTest\Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.UnitTests.vbproj", "{0BE66736-CDAA-4989-88B1-B3F46EBDCA4A}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicScripting", "src\Scripting\VisualBasic\BasicScripting.vbproj", "{3E7DEA65-317B-4F43-A25D-62F18D96CFD7}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Scripting", "src\Scripting\VisualBasic\Microsoft.CodeAnalysis.VisualBasic.Scripting.vbproj", "{3E7DEA65-317B-4F43-A25D-62F18D96CFD7}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Scripting", "src\Scripting\Core\Scripting.csproj", "{12A68549-4E8C-42D6-8703-A09335F97997}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting", "src\Scripting\Core\Microsoft.CodeAnalysis.Scripting.csproj", "{12A68549-4E8C-42D6-8703-A09335F97997}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ScriptingTest", "src\Scripting\CoreTest\ScriptingTest.csproj", "{2DAE4406-7A89-4B5F-95C3-BC5472CE47CE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting.UnitTests", "src\Scripting\CoreTest\Microsoft.CodeAnalysis.Scripting.UnitTests.csproj", "{2DAE4406-7A89-4B5F-95C3-BC5472CE47CE}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpScripting", "src\Scripting\CSharp\CSharpScripting.csproj", "{066F0DBD-C46C-4C20-AFEC-99829A172625}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Scripting", "src\Scripting\CSharp\Microsoft.CodeAnalysis.CSharp.Scripting.csproj", "{066F0DBD-C46C-4C20-AFEC-99829A172625}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpScriptingTest", "src\Scripting\CSharpTest\CSharpScriptingTest.csproj", "{2DAE4406-7A89-4B5F-95C3-BC5422CE47CE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests", "src\Scripting\CSharpTest\Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests.csproj", "{2DAE4406-7A89-4B5F-95C3-BC5422CE47CE}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InteractiveFeatures", "src\Interactive\Features\InteractiveFeatures.csproj", "{8E2A252E-A140-45A6-A81A-2652996EA589}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.InteractiveFeatures", "src\Interactive\Features\Microsoft.CodeAnalysis.InteractiveFeatures.csproj", "{8E2A252E-A140-45A6-A81A-2652996EA589}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpEditorServicesTest", "src\EditorFeatures\CSharpTest\CSharpEditorServicesTest.csproj", "{AC2BCEFB-9298-4621-AC48-1FF5E639E48D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests", "src\EditorFeatures\CSharpTest\Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests.csproj", "{AC2BCEFB-9298-4621-AC48-1FF5E639E48D}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpEditorServicesTest2", "src\EditorFeatures\CSharpTest2\CSharpEditorServicesTest2.csproj", "{16E93074-4252-466C-89A3-3B905ABAF779}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests", "src\EditorFeatures\CSharpTest2\Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests.csproj", "{16E93074-4252-466C-89A3-3B905ABAF779}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EditorServicesTest", "src\EditorFeatures\Test\EditorServicesTest.csproj", "{8CEE3609-A5A9-4A9B-86D7-33118F5D6B33}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.EditorFeatures.UnitTests", "src\EditorFeatures\Test\Microsoft.CodeAnalysis.EditorFeatures.UnitTests.csproj", "{8CEE3609-A5A9-4A9B-86D7-33118F5D6B33}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "EditorServicesTest2", "src\EditorFeatures\Test2\EditorServicesTest2.vbproj", "{3CEA0D69-00D3-40E5-A661-DC41EA07269B}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.EditorFeatures2.UnitTests", "src\EditorFeatures\Test2\Microsoft.CodeAnalysis.EditorFeatures2.UnitTests.vbproj", "{3CEA0D69-00D3-40E5-A661-DC41EA07269B}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ServicesTestUtilities", "src\EditorFeatures\TestUtilities\ServicesTestUtilities.csproj", "{76C6F005-C89D-4348-BB4A-39189DDBEB52}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Services.Test.Utilities", "src\EditorFeatures\TestUtilities\Roslyn.Services.Test.Utilities.csproj", "{76C6F005-C89D-4348-BB4A-39189DDBEB52}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicInteractiveEditorFeatures", "src\Interactive\EditorFeatures\VisualBasic\BasicInteractiveEditorFeatures.vbproj", "{849E516A-595F-474B-ADB4-E099F921CEDF}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.InteractiveEditorFeatures", "src\Interactive\EditorFeatures\VisualBasic\Microsoft.CodeAnalysis.VisualBasic.InteractiveEditorFeatures.vbproj", "{849E516A-595F-474B-ADB4-E099F921CEDF}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpInteractiveEditorFeatures", "src\Interactive\EditorFeatures\CSharp\CSharpInteractiveEditorFeatures.csproj", "{FE2CBEA6-D121-4FAA-AA8B-FC9900BF8C83}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.InteractiveEditorFeatures", "src\Interactive\EditorFeatures\CSharp\Microsoft.CodeAnalysis.CSharp.InteractiveEditorFeatures.csproj", "{FE2CBEA6-D121-4FAA-AA8B-FC9900BF8C83}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InteractiveEditorFeatures", "src\Interactive\EditorFeatures\Core\InteractiveEditorFeatures.csproj", "{92412D1A-0F23-45B5-B196-58839C524917}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.InteractiveEditorFeatures", "src\Interactive\EditorFeatures\Core\Microsoft.CodeAnalysis.InteractiveEditorFeatures.csproj", "{92412D1A-0F23-45B5-B196-58839C524917}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InteractiveHost32", "src\Interactive\Host\InteractiveHost32.csproj", "{EBA4DFA1-6DED-418F-A485-A3B608978906}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InteractiveHostTest", "src\Interactive\HostTest\InteractiveHostTest.csproj", "{8CEE3609-A5A9-4A9B-86D7-33118F5D6B34}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InteractiveHost.UnitTests", "src\Interactive\HostTest\InteractiveHost.UnitTests.csproj", "{8CEE3609-A5A9-4A9B-86D7-33118F5D6B34}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "csi", "src\Interactive\csi\csi.csproj", "{14118347-ED06-4608-9C45-18228273C712}"
EndProject
Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "vbi", "src\Interactive\vbi\vbi.vbproj", "{6E62A0FF-D0DC-4109-9131-AB8E60CDFF7B}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ServicesVisualStudio", "src\VisualStudio\Core\Def\ServicesVisualStudio.csproj", "{86FD5B9A-4FA0-4B10-B59F-CFAF077A859C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.LanguageServices", "src\VisualStudio\Core\Def\Microsoft.VisualStudio.LanguageServices.csproj", "{86FD5B9A-4FA0-4B10-B59F-CFAF077A859C}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ServicesVisualStudioImpl", "src\VisualStudio\Core\Impl\ServicesVisualStudioImpl.csproj", "{C0E80510-4FBE-4B0C-AF2C-4F473787722C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.LanguageServices.Implementation", "src\VisualStudio\Core\Impl\Microsoft.VisualStudio.LanguageServices.Implementation.csproj", "{C0E80510-4FBE-4B0C-AF2C-4F473787722C}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SolutionExplorerShim", "src\VisualStudio\Core\SolutionExplorerShim\SolutionExplorerShim.csproj", "{7BE3DEEB-87F8-4E15-9C21-4F94B0B1C2D6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.LanguageServices.SolutionExplorer", "src\VisualStudio\Core\SolutionExplorerShim\Microsoft.VisualStudio.LanguageServices.SolutionExplorer.csproj", "{7BE3DEEB-87F8-4E15-9C21-4F94B0B1C2D6}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicVisualStudio", "src\VisualStudio\VisualBasic\Impl\BasicVisualStudio.vbproj", "{D49439D7-56D2-450F-A4F0-74CB95D620E6}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.VisualStudio.LanguageServices.VisualBasic", "src\VisualStudio\VisualBasic\Impl\Microsoft.VisualStudio.LanguageServices.VisualBasic.vbproj", "{D49439D7-56D2-450F-A4F0-74CB95D620E6}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicVisualStudioRepl", "src\VisualStudio\VisualBasic\Repl\BasicVisualStudioRepl.vbproj", "{B4A38526-5F15-4CA8-B5E9-0BA04E547023}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.VisualStudio.VisualBasic.Repl", "src\VisualStudio\VisualBasic\Repl\Microsoft.VisualStudio.VisualBasic.Repl.vbproj", "{B4A38526-5F15-4CA8-B5E9-0BA04E547023}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpVisualStudio", "src\VisualStudio\CSharp\Impl\CSharpVisualStudio.csproj", "{5DEFADBD-44EB-47A2-A53E-F1282CC9E4E9}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.LanguageServices.CSharp", "src\VisualStudio\CSharp\Impl\Microsoft.VisualStudio.LanguageServices.CSharp.csproj", "{5DEFADBD-44EB-47A2-A53E-F1282CC9E4E9}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpVisualStudioRepl", "src\VisualStudio\CSharp\Repl\CSharpVisualStudioRepl.csproj", "{737FF62C-F068-4317-84D0-BFB210C17A4E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.CSharp.Repl", "src\VisualStudio\CSharp\Repl\Microsoft.VisualStudio.CSharp.Repl.csproj", "{737FF62C-F068-4317-84D0-BFB210C17A4E}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpVisualStudioTest", "src\VisualStudio\CSharp\Test\CSharpVisualStudioTest.csproj", "{91C574AD-0352-47E9-A019-EE02CC32A396}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests", "src\VisualStudio\CSharp\Test\Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests.csproj", "{91C574AD-0352-47E9-A019-EE02CC32A396}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "ServicesVisualStudioTest", "src\VisualStudio\Core\Test\ServicesVisualStudioTest.vbproj", "{A1455D30-55FC-45EF-8759-3AEBDB13D940}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.VisualStudio.LanguageServices.UnitTests", "src\VisualStudio\Core\Test\Microsoft.VisualStudio.LanguageServices.UnitTests.vbproj", "{A1455D30-55FC-45EF-8759-3AEBDB13D940}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioSetup", "src\VisualStudio\Setup\VisualStudioSetup.csproj", "{201EC5B7-F91E-45E5-B9F2-67A266CCE6FC}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.VisualStudio.Setup", "src\VisualStudio\Setup\Roslyn.VisualStudio.Setup.csproj", "{201EC5B7-F91E-45E5-B9F2-67A266CCE6FC}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioInteractiveComponents", "src\VisualStudio\VisualStudioInteractiveComponents\VisualStudioInteractiveComponents.csproj", "{2169F526-8A88-435D-8732-486ACA095A6A}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.VisualStudio.InteractiveComponents", "src\VisualStudio\VisualStudioInteractiveComponents\Roslyn.VisualStudio.InteractiveComponents.csproj", "{2169F526-8A88-435D-8732-486ACA095A6A}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioInteractiveServices", "src\VisualStudio\InteractiveServices\VisualStudioInteractiveServices.csproj", "{A31228BB-F05C-4D4A-B98A-0E681D876B7C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.InteractiveServices", "src\VisualStudio\InteractiveServices\Microsoft.VisualStudio.InteractiveServices.csproj", "{A31228BB-F05C-4D4A-B98A-0E681D876B7C}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioDiagnosticsWindow", "src\VisualStudio\VisualStudioDiagnosticsToolWindow\VisualStudioDiagnosticsWindow.csproj", "{A486D7DE-F614-409D-BB41-0FFDF582E35C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.VisualStudio.DiagnosticsWindow", "src\VisualStudio\VisualStudioDiagnosticsToolWindow\Roslyn.VisualStudio.DiagnosticsWindow.csproj", "{A486D7DE-F614-409D-BB41-0FFDF582E35C}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ExpressionEvaluatorPackage", "src\ExpressionEvaluator\Package\ExpressionEvaluatorPackage.csproj", "{B617717C-7881-4F01-AB6D-B1B6CC0483A0}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpExpressionCompiler", "src\ExpressionEvaluator\CSharp\Source\ExpressionCompiler\CSharpExpressionCompiler.csproj", "{FD6BA96C-7905-4876-8BCC-E38E2CA64F31}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.ExpressionCompiler", "src\ExpressionEvaluator\CSharp\Source\ExpressionCompiler\Microsoft.CodeAnalysis.CSharp.ExpressionCompiler.csproj", "{FD6BA96C-7905-4876-8BCC-E38E2CA64F31}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpExpressionCompilerTest", "src\ExpressionEvaluator\CSharp\Test\ExpressionCompiler\CSharpExpressionCompilerTest.csproj", "{AE297965-4D56-4BA9-85EB-655AC4FC95A0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.ExpressionCompiler.UnitTests", "src\ExpressionEvaluator\CSharp\Test\ExpressionCompiler\Microsoft.CodeAnalysis.CSharp.ExpressionCompiler.UnitTests.csproj", "{AE297965-4D56-4BA9-85EB-655AC4FC95A0}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpResultProviderTest", "src\ExpressionEvaluator\CSharp\Test\ResultProvider\CSharpResultProviderTest.csproj", "{60DB272A-21C9-4E8D-9803-FF4E132392C8}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.ResultProvider.UnitTests", "src\ExpressionEvaluator\CSharp\Test\ResultProvider\Microsoft.CodeAnalysis.CSharp.ResultProvider.UnitTests.csproj", "{60DB272A-21C9-4E8D-9803-FF4E132392C8}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicExpressionCompiler", "src\ExpressionEvaluator\VisualBasic\Source\ExpressionCompiler\BasicExpressionCompiler.vbproj", "{73242A2D-6300-499D-8C15-FADF7ECB185C}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler", "src\ExpressionEvaluator\VisualBasic\Source\ExpressionCompiler\Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler.vbproj", "{73242A2D-6300-499D-8C15-FADF7ECB185C}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicExpressionCompilerTest", "src\ExpressionEvaluator\VisualBasic\Test\ExpressionCompiler\BasicExpressionCompilerTest.vbproj", "{AC5E3515-482C-4C6A-92D9-D0CEA687DFC2}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler.UnitTests", "src\ExpressionEvaluator\VisualBasic\Test\ExpressionCompiler\Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler.UnitTests.vbproj", "{AC5E3515-482C-4C6A-92D9-D0CEA687DFC2}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ExpressionCompiler", "src\ExpressionEvaluator\Core\Source\ExpressionCompiler\ExpressionCompiler.csproj", "{B8DA3A90-A60C-42E3-9D8E-6C67B800C395}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ExpressionCompiler", "src\ExpressionEvaluator\Core\Source\ExpressionCompiler\Microsoft.CodeAnalysis.ExpressionCompiler.csproj", "{B8DA3A90-A60C-42E3-9D8E-6C67B800C395}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicResultProviderTest", "src\ExpressionEvaluator\VisualBasic\Test\ResultProvider\BasicResultProviderTest.vbproj", "{ACE53515-482C-4C6A-E2D2-4242A687DFEE}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.ResultProvider.UnitTests", "src\ExpressionEvaluator\VisualBasic\Test\ResultProvider\Microsoft.CodeAnalysis.VisualBasic.ResultProvider.UnitTests.vbproj", "{ACE53515-482C-4C6A-E2D2-4242A687DFEE}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ExpressionCompilerTestUtilities", "src\ExpressionEvaluator\Core\Test\ExpressionCompiler\ExpressionCompilerTestUtilities.csproj", "{21B80A31-8FF9-4E3A-8403-AABD635AEED9}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ExpressionCompiler.Utilities", "src\ExpressionEvaluator\Core\Test\ExpressionCompiler\Microsoft.CodeAnalysis.ExpressionCompiler.Utilities.csproj", "{21B80A31-8FF9-4E3A-8403-AABD635AEED9}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ResultProviderTestUtilities", "src\ExpressionEvaluator\Core\Test\ResultProvider\ResultProviderTestUtilities.csproj", "{ABDBAC1E-350E-4DC3-BB45-3504404545EE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ResultProvider.Utilities", "src\ExpressionEvaluator\Core\Test\ResultProvider\Microsoft.CodeAnalysis.ResultProvider.Utilities.csproj", "{ABDBAC1E-350E-4DC3-BB45-3504404545EE}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "AnalyzerDriver", "src\Compilers\Core\AnalyzerDriver\AnalyzerDriver.shproj", "{D0BC9BE7-24F6-40CA-8DC6-FCB93BD44B34}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpWinRTTest", "src\Compilers\CSharp\Test\WinRT\CSharpWinRTTest.csproj", "{FCFA8808-A1B6-48CC-A1EA-0B8CA8AEDA8E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests", "src\Compilers\CSharp\Test\WinRT\Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests.csproj", "{FCFA8808-A1B6-48CC-A1EA-0B8CA8AEDA8E}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MSBuildTaskTests", "src\Compilers\Core\MSBuildTaskTests\MSBuildTaskTests.csproj", "{1DFEA9C5-973C-4179-9B1B-0F32288E1EF2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Build.Tasks.CodeAnalysis.UnitTests", "src\Compilers\Core\MSBuildTaskTests\Microsoft.Build.Tasks.CodeAnalysis.UnitTests.csproj", "{1DFEA9C5-973C-4179-9B1B-0F32288E1EF2}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "BasicResultProvider", "src\ExpressionEvaluator\VisualBasic\Source\ResultProvider\BasicResultProvider.shproj", "{3140FE61-0856-4367-9AA3-8081B9A80E35}"
EndProject
Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicResultProvider.NetFX20", "src\ExpressionEvaluator\VisualBasic\Source\ResultProvider\NetFX20\BasicResultProvider.NetFX20.vbproj", "{76242A2D-2600-49DD-8C15-FEA07ECB1842}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicResultProvider.Portable", "src\ExpressionEvaluator\VisualBasic\Source\ResultProvider\Portable\BasicResultProvider.Portable.vbproj", "{76242A2D-2600-49DD-8C15-FEA07ECB1843}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.ResultProvider", "src\ExpressionEvaluator\VisualBasic\Source\ResultProvider\Portable\Microsoft.CodeAnalysis.VisualBasic.ResultProvider.vbproj", "{76242A2D-2600-49DD-8C15-FEA07ECB1843}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "CSharpResultProvider", "src\ExpressionEvaluator\CSharp\Source\ResultProvider\CSharpResultProvider.shproj", "{3140FE61-0856-4367-9AA3-8081B9A80E36}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpResultProvider.NetFX20", "src\ExpressionEvaluator\CSharp\Source\ResultProvider\NetFX20\CSharpResultProvider.NetFX20.csproj", "{BF9DAC1E-3A5E-4DC3-BB44-9A64E0D4E9D3}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpResultProvider.Portable", "src\ExpressionEvaluator\CSharp\Source\ResultProvider\Portable\CSharpResultProvider.Portable.csproj", "{BF9DAC1E-3A5E-4DC3-BB44-9A64E0D4E9D4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.ResultProvider", "src\ExpressionEvaluator\CSharp\Source\ResultProvider\Portable\Microsoft.CodeAnalysis.CSharp.ResultProvider.csproj", "{BF9DAC1E-3A5E-4DC3-BB44-9A64E0D4E9D4}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "ResultProvider", "src\ExpressionEvaluator\Core\Source\ResultProvider\ResultProvider.shproj", "{BB3CA047-5D00-48D4-B7D3-233C1265C065}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ResultProvider.NetFX20", "src\ExpressionEvaluator\Core\Source\ResultProvider\NetFX20\ResultProvider.NetFX20.csproj", "{BEDC5A4A-809E-4017-9CFD-6C8D4E1847F0}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ResultProvider.Portable", "src\ExpressionEvaluator\Core\Source\ResultProvider\Portable\ResultProvider.Portable.csproj", "{FA0E905D-EC46-466D-B7B2-3B5557F9428C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ResultProvider", "src\ExpressionEvaluator\Core\Source\ResultProvider\Portable\Microsoft.CodeAnalysis.ResultProvider.csproj", "{FA0E905D-EC46-466D-B7B2-3B5557F9428C}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "vbc", "src\Compilers\VisualBasic\vbc\vbc.csproj", "{E58EE9D7-1239-4961-A0C1-F9EC3952C4C1}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "src\Test\Utilities\Portable\TestUtilities.csproj", "{CCBD3438-3E84-40A9-83AD-533F23BCFCA5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Test.Utilities", "src\Test\Utilities\Portable\Roslyn.Test.Utilities.csproj", "{CCBD3438-3E84-40A9-83AD-533F23BCFCA5}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ScriptingTest.Desktop", "src\Scripting\CoreTest.Desktop\ScriptingTest.Desktop.csproj", "{6FD1CC3E-6A99-4736-9B8D-757992DDE75D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting.Desktop.UnitTests", "src\Scripting\CoreTest.Desktop\Microsoft.CodeAnalysis.Scripting.Desktop.UnitTests.csproj", "{6FD1CC3E-6A99-4736-9B8D-757992DDE75D}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpScriptingTest.Desktop", "src\Scripting\CSharpTest.Desktop\CSharpScriptingTest.Desktop.csproj", "{286B01F3-811A-40A7-8C1F-10C9BB0597F7}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.Scripting.Desktop.UnitTests", "src\Scripting\CSharpTest.Desktop\Microsoft.CodeAnalysis.CSharp.Scripting.Desktop.UnitTests.csproj", "{286B01F3-811A-40A7-8C1F-10C9BB0597F7}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicScriptingTest.Desktop", "src\Scripting\VisualBasicTest.Desktop\BasicScriptingTest.Desktop.vbproj", "{24973B4C-FD09-4EE1-97F4-EA03E6B12040}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Scripting.Desktop.UnitTests", "src\Scripting\VisualBasicTest.Desktop\Microsoft.CodeAnalysis.VisualBasic.Scripting.Desktop.UnitTests.vbproj", "{24973B4C-FD09-4EE1-97F4-EA03E6B12040}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicScriptingTest", "src\Scripting\VisualBasicTest\BasicScriptingTest.vbproj", "{ABC7262E-1053-49F3-B846-E3091BB92E8C}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests", "src\Scripting\VisualBasicTest\Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests.vbproj", "{ABC7262E-1053-49F3-B846-E3091BB92E8C}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Diagnostics", "src\Test\Diagnostics\Diagnostics.csproj", "{E2E889A5-2489-4546-9194-47C63E49EAEB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Hosting.Diagnostics", "src\Test\Diagnostics\Roslyn.Hosting.Diagnostics.csproj", "{E2E889A5-2489-4546-9194-47C63E49EAEB}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "BasicAnalyzerDriver", "src\Compilers\VisualBasic\BasicAnalyzerDriver\BasicAnalyzerDriver.shproj", "{E8F0BAA5-7327-43D1-9A51-644E81AE55F1}"
EndProject
@@ -273,102 +275,126 @@ Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "CSharpAnalyzerDriver", "src
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "CommandLine", "src\Compilers\Core\CommandLine\CommandLine.shproj", "{AD6F474E-E6D4-4217-91F3-B7AF1BE31CCC}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CompilerExtension", "src\Compilers\Extension\CompilerExtension.csproj", "{43026D51-3083-4850-928D-07E1883D5B1A}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Compilers.Extension", "src\Compilers\Extension\Roslyn.Compilers.Extension.csproj", "{43026D51-3083-4850-928D-07E1883D5B1A}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioIntegrationTestSetup", "src\VisualStudio\IntegrationTest\TestSetup\VisualStudioIntegrationTestSetup.csproj", "{A88AB44F-7F9D-43F6-A127-83BB65E5A7E2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.IntegrationTest.Setup", "src\VisualStudio\IntegrationTest\TestSetup\Microsoft.VisualStudio.IntegrationTest.Setup.csproj", "{A88AB44F-7F9D-43F6-A127-83BB65E5A7E2}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioIntegrationTests", "src\VisualStudio\IntegrationTest\IntegrationTests\VisualStudioIntegrationTests.csproj", "{E5A55C16-A5B9-4874-9043-A5266DC02F58}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.LanguageServices.IntegrationTests", "src\VisualStudio\IntegrationTest\IntegrationTests\Microsoft.VisualStudio.LanguageServices.IntegrationTests.csproj", "{E5A55C16-A5B9-4874-9043-A5266DC02F58}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioIntegrationTestUtilities", "src\VisualStudio\IntegrationTest\TestUtilities\VisualStudioIntegrationTestUtilities.csproj", "{3BED15FD-D608-4573-B432-1569C1026F6D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.IntegrationTest.Utilities", "src\VisualStudio\IntegrationTest\TestUtilities\Microsoft.VisualStudio.IntegrationTest.Utilities.csproj", "{3BED15FD-D608-4573-B432-1569C1026F6D}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Perf.Tests", "src\Test\Perf\tests\Perf.Tests.csproj", "{DA0D2A70-A2F9-4654-A99A-3227EDF54FF1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Test.Performance.Tests", "src\Test\Perf\tests\Roslyn.Test.Performance.Tests.csproj", "{DA0D2A70-A2F9-4654-A99A-3227EDF54FF1}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "XamlVisualStudio", "src\VisualStudio\Xaml\Impl\XamlVisualStudio.csproj", "{971E832B-7471-48B5-833E-5913188EC0E4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.LanguageServices.Xaml", "src\VisualStudio\Xaml\Impl\Microsoft.VisualStudio.LanguageServices.Xaml.csproj", "{971E832B-7471-48B5-833E-5913188EC0E4}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Perf.Utilities", "src\Test\Perf\Utilities\Perf.Utilities.csproj", "{59AD474E-2A35-4E8A-A74D-E33479977FBF}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Test.Performance.Utilities", "src\Test\Perf\Utilities\Roslyn.Test.Performance.Utilities.csproj", "{59AD474E-2A35-4E8A-A74D-E33479977FBF}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Microsoft.CodeAnalysis.Debugging", "src\Dependencies\CodeAnalysis.Debugging\Microsoft.CodeAnalysis.Debugging.shproj", "{D73ADF7D-2C1C-42AE-B2AB-EDC9497E4B71}"
EndProject
Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Microsoft.CodeAnalysis.PooledObjects", "src\Dependencies\PooledObjects\Microsoft.CodeAnalysis.PooledObjects.shproj", "{C1930979-C824-496B-A630-70F5369A636F}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RemoteWorkspaces", "src\Workspaces\Remote\Core\RemoteWorkspaces.csproj", "{F822F72A-CC87-4E31-B57D-853F65CBEBF3}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Remote.Workspaces", "src\Workspaces\Remote\Core\Microsoft.CodeAnalysis.Remote.Workspaces.csproj", "{F822F72A-CC87-4E31-B57D-853F65CBEBF3}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ServiceHub", "src\Workspaces\Remote\ServiceHub\ServiceHub.csproj", "{80FDDD00-9393-47F7-8BAF-7E87CE011068}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Remote.ServiceHub", "src\Workspaces\Remote\ServiceHub\Microsoft.CodeAnalysis.Remote.ServiceHub.csproj", "{80FDDD00-9393-47F7-8BAF-7E87CE011068}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RepoUtil", "src\Tools\RepoUtil\RepoUtil.csproj", "{1CA184D3-89CB-4074-BEC5-F8AEBA657D41}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MSBuildTask", "src\Compilers\Core\MSBuildTask\MSBuildTask.csproj", "{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Build.Tasks.CodeAnalysis", "src\Compilers\Core\MSBuildTask\Microsoft.Build.Tasks.CodeAnalysis.csproj", "{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RemoteHostClientMock", "src\VisualStudio\RemoteHostClientMock\RemoteHostClientMock.csproj", "{7259740A-FD0E-480F-A7D4-08BE90AC9051}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.VisualStudio.RemoteHostClientMock", "src\VisualStudio\RemoteHostClientMock\Roslyn.VisualStudio.RemoteHostClientMock.csproj", "{7259740A-FD0E-480F-A7D4-08BE90AC9051}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioTest.Next", "src\VisualStudio\Core\Test.Next\VisualStudioTest.Next.csproj", "{2E1658E2-5045-4F85-A64C-C0ECCD39F719}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.VisualStudio.Next.UnitTests", "src\VisualStudio\Core\Test.Next\Roslyn.VisualStudio.Next.UnitTests.csproj", "{2E1658E2-5045-4F85-A64C-C0ECCD39F719}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BuildBoss", "src\Tools\BuildBoss\BuildBoss.csproj", "{9C0660D9-48CA-40E1-BABA-8F6A1F11FE10}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ScriptingTestUtilities", "src\Scripting\CoreTestUtilities\ScriptingTestUtilities.csproj", "{21A01C2D-2501-4619-8144-48977DD22D9C}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WorkspacesTestUtilities", "src\Workspaces\CoreTestUtilities\WorkspacesTestUtilities.csproj", "{3F2FDC1C-DC6F-44CB-B4A1-A9026F25D66E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting.TestUtilities", "src\Scripting\CoreTestUtilities\Microsoft.CodeAnalysis.Scripting.TestUtilities.csproj", "{21A01C2D-2501-4619-8144-48977DD22D9C}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Toolset", "build\Toolset\Toolset.csproj", "{57557F32-0635-421A-BCF8-549AED50F764}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.Services.UnitTests.Utilities", "src\Workspaces\CoreTestUtilities\Roslyn.Services.UnitTests.Utilities.csproj", "{3F2FDC1C-DC6F-44CB-B4A1-A9026F25D66E}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "ServicesTestUtilities2", "src\EditorFeatures\TestUtilities2\ServicesTestUtilities2.vbproj", "{3DFB4701-E3D6-4435-9F70-A6E35822C4F2}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities", "src\EditorFeatures\TestUtilities2\Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities.vbproj", "{3DFB4701-E3D6-4435-9F70-A6E35822C4F2}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "VisualStudioTestUtilities2", "src\VisualStudio\TestUtilities2\VisualStudioTestUtilities2.vbproj", "{69F853E5-BD04-4842-984F-FC68CC51F402}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.VisualStudio.LanguageServices.Test.Utilities2", "src\VisualStudio\TestUtilities2\Microsoft.VisualStudio.LanguageServices.Test.Utilities2.vbproj", "{69F853E5-BD04-4842-984F-FC68CC51F402}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FunctionResolver", "src\ExpressionEvaluator\Core\Source\FunctionResolver\FunctionResolver.csproj", "{6FC8E6F5-659C-424D-AEB5-331B95883E29}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.FunctionResolver", "src\ExpressionEvaluator\Core\Source\FunctionResolver\Microsoft.CodeAnalysis.FunctionResolver.csproj", "{6FC8E6F5-659C-424D-AEB5-331B95883E29}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FunctionResolverTest", "src\ExpressionEvaluator\Core\Test\FunctionResolver\FunctionResolverTest.csproj", "{DD317BE1-42A1-4795-B1D4-F370C40D649A}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.FunctionResolver.UnitTests", "src\ExpressionEvaluator\Core\Test\FunctionResolver\Microsoft.CodeAnalysis.FunctionResolver.UnitTests.csproj", "{DD317BE1-42A1-4795-B1D4-F370C40D649A}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RazorVisualStudio", "src\VisualStudio\Razor\RazorVisualStudio.csproj", "{0C0EEB55-4B6D-4F2B-B0BB-B9EB2BA9E980}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.LanguageServices.Razor.RemoteClient", "src\VisualStudio\Razor\Microsoft.VisualStudio.LanguageServices.Razor.RemoteClient.csproj", "{0C0EEB55-4B6D-4F2B-B0BB-B9EB2BA9E980}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RazorServiceHub", "src\Workspaces\Remote\Razor\RazorServiceHub.csproj", "{B6FC05F2-0E49-4BE2-8030-ACBB82B7F431}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Remote.Razor.ServiceHub", "src\Workspaces\Remote\Razor\Microsoft.CodeAnalysis.Remote.Razor.ServiceHub.csproj", "{B6FC05F2-0E49-4BE2-8030-ACBB82B7F431}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualStudioSetup.Dependencies", "src\VisualStudio\Setup.Dependencies\VisualStudioSetup.Dependencies.csproj", "{1688E1E5-D510-4E06-86F3-F8DB10B1393D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.VisualStudio.Setup.Dependencies", "src\VisualStudio\Setup.Dependencies\Roslyn.VisualStudio.Setup.Dependencies.csproj", "{1688E1E5-D510-4E06-86F3-F8DB10B1393D}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StackDepthTest", "src\Test\Perf\StackDepthTest\StackDepthTest.csproj", "{F040CEC5-5E11-4DBD-9F6A-250478E28177}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeStyle", "src\CodeStyle\Core\Analyzers\CodeStyle.csproj", "{275812EE-DEDB-4232-9439-91C9757D2AE4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CodeStyle", "src\CodeStyle\Core\Analyzers\Microsoft.CodeAnalysis.CodeStyle.csproj", "{275812EE-DEDB-4232-9439-91C9757D2AE4}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeStyleFixes", "src\CodeStyle\Core\CodeFixes\CodeStyleFixes.csproj", "{5FF1E493-69CC-4D0B-83F2-039F469A04E1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CodeStyle.Fixes", "src\CodeStyle\Core\CodeFixes\Microsoft.CodeAnalysis.CodeStyle.Fixes.csproj", "{5FF1E493-69CC-4D0B-83F2-039F469A04E1}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeStyle", "src\CodeStyle\CSharp\Analyzers\CSharpCodeStyle.csproj", "{AA87BFED-089A-4096-B8D5-690BDC7D5B24}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.CodeStyle", "src\CodeStyle\CSharp\Analyzers\Microsoft.CodeAnalysis.CSharp.CodeStyle.csproj", "{AA87BFED-089A-4096-B8D5-690BDC7D5B24}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeStyleFixes", "src\CodeStyle\CSharp\CodeFixes\CSharpCodeStyleFixes.csproj", "{A07ABCF5-BC43-4EE9-8FD8-B2D77FD54D73}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes", "src\CodeStyle\CSharp\CodeFixes\Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes.csproj", "{A07ABCF5-BC43-4EE9-8FD8-B2D77FD54D73}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeStyle", "src\CodeStyle\VisualBasic\Analyzers\BasicCodeStyle.vbproj", "{2531A8C4-97DD-47BC-A79C-B7846051E137}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.CodeStyle", "src\CodeStyle\VisualBasic\Analyzers\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.vbproj", "{2531A8C4-97DD-47BC-A79C-B7846051E137}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeStyleFixes", "src\CodeStyle\VisualBasic\CodeFixes\BasicCodeStyleFixes.vbproj", "{0141285D-8F6C-42C7-BAF3-3C0CCD61C716}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes", "src\CodeStyle\VisualBasic\CodeFixes\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes.vbproj", "{0141285D-8F6C-42C7-BAF3-3C0CCD61C716}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeStyleTests", "src\CodeStyle\Core\Tests\CodeStyleTests.csproj", "{9FF1205F-1D7C-4EE4-B038-3456FE6EBEAF}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CodeStyle.UnitTests", "src\CodeStyle\Core\Tests\Microsoft.CodeAnalysis.CodeStyle.UnitTests.csproj", "{9FF1205F-1D7C-4EE4-B038-3456FE6EBEAF}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeStyleTests", "src\CodeStyle\CSharp\Tests\CSharpCodeStyleTests.csproj", "{5018D049-5870-465A-889B-C742CE1E31CB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests", "src\CodeStyle\CSharp\Tests\Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests.csproj", "{5018D049-5870-465A-889B-C742CE1E31CB}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeStyleTests", "src\CodeStyle\VisualBasic\Tests\BasicCodeStyleTests.vbproj", "{E512C6C1-F085-4AD7-B0D9-E8F1A0A2A510}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.CodeStyle.UnitTests", "src\CodeStyle\VisualBasic\Tests\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.UnitTests.vbproj", "{E512C6C1-F085-4AD7-B0D9-E8F1A0A2A510}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RoslynPublish", "src\Tools\RoslynPublish\RoslynPublish.csproj", "{2D36C343-BB6A-4CB5-902B-E2145ACCB58F}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EditorFeatures.Wpf", "src\EditorFeatures\Core.Wpf\EditorFeatures.Wpf.csproj", "{FFB00FB5-8C8C-4A02-B67D-262B9D28E8B1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.EditorFeatures.Wpf", "src\EditorFeatures\Core.Wpf\Microsoft.CodeAnalysis.EditorFeatures.Wpf.csproj", "{FFB00FB5-8C8C-4A02-B67D-262B9D28E8B1}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AnalyzerRunner", "src\Tools\AnalyzerRunner\AnalyzerRunner.csproj", "{60166C60-813C-46C4-911D-2411B4ABBC0F}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ILAsm", "src\Tools\ILAsm\ILAsm.csproj", "{DA8522ED-02BC-499C-AC71-1DF884F63987}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IlAsmDeploy", "src\Tools\ILAsm\IlAsmDeploy.csproj", "{DA8522ED-02BC-499C-AC71-1DF884F63987}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BuildUtil", "src\Tools\BuildUtil\BuildUtil.csproj", "{137922A2-5B1E-44C4-B0EC-0F49D2BD323A}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Roslyn.MSBuild.Util", "src\Tools\BuildUtil\Roslyn.MSBuild.Util.csproj", "{137922A2-5B1E-44C4-B0EC-0F49D2BD323A}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Debugging.Package", "src\Dependencies\CodeAnalysis.Debugging\Microsoft.CodeAnalysis.Debugging.Package.csproj", "{FC2AE90B-2E4B-4045-9FDD-73D4F5ED6C89}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.PooledObjects.Package", "src\Dependencies\PooledObjects\Microsoft.CodeAnalysis.PooledObjects.Package.csproj", "{49E7C367-181B-499C-AC2E-8E17C81418D6}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Workspaces.MSBuild.Test", "src\Workspaces\MSBuildTest\Workspaces.MSBuild.Test.csproj", "{037F06F0-3BE8-42D0-801E-2F74FC380AB8}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevDivPackagesDebugger", "src\Setup\DevDivPackages\Debugger\DevDivPackagesDebugger.csproj", "{18BDB5D5-340B-4834-B4FC-0327729A4A26}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests", "src\Workspaces\MSBuildTest\Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj", "{037F06F0-3BE8-42D0-801E-2F74FC380AB8}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "DevDivInsertionFiles", "src\Setup\DevDivInsertionFiles\DevDivInsertionFiles.vbproj", "{5FE910A9-E7C9-40E1-AAF1-6C6C7DD61B67}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevDivPackagesDebugger_DoNotUse", "src\Setup\DevDivPackages\Debugger\DevDivPackagesDebugger_DoNotUse.csproj", "{18BDB5D5-340B-4834-B4FC-0327729A4A26}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NuGetProjectPackUtil", "src\NuGet\NuGetProjectPackUtil.csproj", "{B2B261E8-56EC-45DC-8AB8-A491A065EFD4}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Roslyn.BuildDevDivInsertionFiles", "src\Setup\DevDivInsertionFiles\Roslyn.BuildDevDivInsertionFiles.vbproj", "{5FE910A9-E7C9-40E1-AAF1-6C6C7DD61B67}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InteractiveHost64", "src\Interactive\Host\InteractiveHost64.csproj", "{2F11618A-9251-4609-B3D5-CE4D2B3D3E49}"
EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualStudio.IntegrationTest.IntegrationService", "src\VisualStudio\IntegrationTest\IntegrationService\Microsoft.VisualStudio.IntegrationTest.IntegrationService.csproj", "{764D2C19-0187-4837-A2A3-96DDC6EF4CE2}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CompilerBenchmarks", "src\Tools\CompilerBenchmarks\CompilerBenchmarks.csproj", "{9860FCF7-3111-4C12-A16F-ACEBA42D930F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Net.Compilers.Package", "src\NuGet\Microsoft.Net.Compilers\Microsoft.Net.Compilers.Package.csproj", "{9102ECF3-5CD1-4107-B8B7-F3795A52D790}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.NETCore.Compilers.Package", "src\NuGet\Microsoft.NETCore.Compilers\Microsoft.NETCore.Compilers.Package.csproj", "{50CF5D8F-F82F-4210-A06E-37CC9BFFDD49}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Compilers.Package", "src\NuGet\Microsoft.CodeAnalysis.Compilers.Package.csproj", "{CFA94A39-4805-456D-A369-FC35CCC170E9}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Packages", "Packages", "{C52D8057-43AF-40E6-A01B-6CDBB7301985}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Scripting.Package", "src\NuGet\Microsoft.CodeAnalysis.Scripting.Package.csproj", "{4A490CBC-37F4-4859-AFDB-4B0833D144AF}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.EditorFeatures.Package", "src\NuGet\Microsoft.CodeAnalysis.EditorFeatures.Package.csproj", "{34E868E9-D30B-4FB5-BC61-AFC4A9612A0F}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Packages", "Packages", "{BE25E872-1667-4649-9D19-96B83E75A44E}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VS.ExternalAPIs.Roslyn.Package", "src\NuGet\VisualStudio\VS.ExternalAPIs.Roslyn.Package.csproj", "{0EB22BD1-B8B1-417D-8276-F475C2E190FF}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VS.Tools.Roslyn.Package", "src\NuGet\VisualStudio\VS.Tools.Roslyn.Package.csproj", "{3636D3E2-E3EF-4815-B020-819F382204CD}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Package", "src\NuGet\Microsoft.CodeAnalysis.Package.csproj", "{B9843F65-262E-4F40-A0BC-2CBEF7563A44}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PortableFacades.Setup", "src\Setup\DevDivVsix\PortableFacades\PortableFacades.Setup.csproj", "{952808C5-799A-4CAA-964C-2AA78458CEC7}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Compilers.Setup", "src\Setup\DevDivVsix\CompilersPackage\Microsoft.CodeAnalysis.Compilers.Setup.csproj", "{03607817-6800-40B6-BEAA-D6F437CD62B7}"
+EndProject
Global
GlobalSection(SharedMSBuildProjectFiles) = preSolution
src\Compilers\VisualBasic\BasicAnalyzerDriver\BasicAnalyzerDriver.projitems*{2523d0e6-df32-4a3e-8ae0-a19bffae2ef6}*SharedItemsImports = 4
@@ -434,6 +460,10 @@ Global
{4462B57A-7245-4146-B504-D46FDE762948}.Debug|Any CPU.Build.0 = Debug|Any CPU
{4462B57A-7245-4146-B504-D46FDE762948}.Release|Any CPU.ActiveCfg = Release|Any CPU
{4462B57A-7245-4146-B504-D46FDE762948}.Release|Any CPU.Build.0 = Release|Any CPU
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1}.Release|Any CPU.Build.0 = Release|Any CPU
{B2C33A93-DB30-4099-903E-77D75C4C3F45}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{B2C33A93-DB30-4099-903E-77D75C4C3F45}.Debug|Any CPU.Build.0 = Debug|Any CPU
{B2C33A93-DB30-4099-903E-77D75C4C3F45}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -866,10 +896,6 @@ Global
{3F2FDC1C-DC6F-44CB-B4A1-A9026F25D66E}.Debug|Any CPU.Build.0 = Debug|Any CPU
{3F2FDC1C-DC6F-44CB-B4A1-A9026F25D66E}.Release|Any CPU.ActiveCfg = Release|Any CPU
{3F2FDC1C-DC6F-44CB-B4A1-A9026F25D66E}.Release|Any CPU.Build.0 = Release|Any CPU
- {57557F32-0635-421A-BCF8-549AED50F764}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
- {57557F32-0635-421A-BCF8-549AED50F764}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {57557F32-0635-421A-BCF8-549AED50F764}.Release|Any CPU.ActiveCfg = Release|Any CPU
- {57557F32-0635-421A-BCF8-549AED50F764}.Release|Any CPU.Build.0 = Release|Any CPU
{3DFB4701-E3D6-4435-9F70-A6E35822C4F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{3DFB4701-E3D6-4435-9F70-A6E35822C4F2}.Debug|Any CPU.Build.0 = Debug|Any CPU
{3DFB4701-E3D6-4435-9F70-A6E35822C4F2}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -978,14 +1004,58 @@ Global
{5FE910A9-E7C9-40E1-AAF1-6C6C7DD61B67}.Debug|Any CPU.Build.0 = Debug|Any CPU
{5FE910A9-E7C9-40E1-AAF1-6C6C7DD61B67}.Release|Any CPU.ActiveCfg = Release|Any CPU
{5FE910A9-E7C9-40E1-AAF1-6C6C7DD61B67}.Release|Any CPU.Build.0 = Release|Any CPU
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4}.Release|Any CPU.ActiveCfg = Release|Any CPU
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4}.Release|Any CPU.Build.0 = Release|Any CPU
{2F11618A-9251-4609-B3D5-CE4D2B3D3E49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{2F11618A-9251-4609-B3D5-CE4D2B3D3E49}.Debug|Any CPU.Build.0 = Debug|Any CPU
{2F11618A-9251-4609-B3D5-CE4D2B3D3E49}.Release|Any CPU.ActiveCfg = Release|Any CPU
{2F11618A-9251-4609-B3D5-CE4D2B3D3E49}.Release|Any CPU.Build.0 = Release|Any CPU
+ {764D2C19-0187-4837-A2A3-96DDC6EF4CE2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {764D2C19-0187-4837-A2A3-96DDC6EF4CE2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {764D2C19-0187-4837-A2A3-96DDC6EF4CE2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {764D2C19-0187-4837-A2A3-96DDC6EF4CE2}.Release|Any CPU.Build.0 = Release|Any CPU
+ {9860FCF7-3111-4C12-A16F-ACEBA42D930F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {9860FCF7-3111-4C12-A16F-ACEBA42D930F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {9860FCF7-3111-4C12-A16F-ACEBA42D930F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {9860FCF7-3111-4C12-A16F-ACEBA42D930F}.Release|Any CPU.Build.0 = Release|Any CPU
+ {9102ECF3-5CD1-4107-B8B7-F3795A52D790}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {9102ECF3-5CD1-4107-B8B7-F3795A52D790}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {9102ECF3-5CD1-4107-B8B7-F3795A52D790}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {9102ECF3-5CD1-4107-B8B7-F3795A52D790}.Release|Any CPU.Build.0 = Release|Any CPU
+ {50CF5D8F-F82F-4210-A06E-37CC9BFFDD49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {50CF5D8F-F82F-4210-A06E-37CC9BFFDD49}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {50CF5D8F-F82F-4210-A06E-37CC9BFFDD49}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {50CF5D8F-F82F-4210-A06E-37CC9BFFDD49}.Release|Any CPU.Build.0 = Release|Any CPU
+ {CFA94A39-4805-456D-A369-FC35CCC170E9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {CFA94A39-4805-456D-A369-FC35CCC170E9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {CFA94A39-4805-456D-A369-FC35CCC170E9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {CFA94A39-4805-456D-A369-FC35CCC170E9}.Release|Any CPU.Build.0 = Release|Any CPU
+ {4A490CBC-37F4-4859-AFDB-4B0833D144AF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {4A490CBC-37F4-4859-AFDB-4B0833D144AF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {4A490CBC-37F4-4859-AFDB-4B0833D144AF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {4A490CBC-37F4-4859-AFDB-4B0833D144AF}.Release|Any CPU.Build.0 = Release|Any CPU
+ {34E868E9-D30B-4FB5-BC61-AFC4A9612A0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {34E868E9-D30B-4FB5-BC61-AFC4A9612A0F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {34E868E9-D30B-4FB5-BC61-AFC4A9612A0F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {34E868E9-D30B-4FB5-BC61-AFC4A9612A0F}.Release|Any CPU.Build.0 = Release|Any CPU
+ {0EB22BD1-B8B1-417D-8276-F475C2E190FF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {0EB22BD1-B8B1-417D-8276-F475C2E190FF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {0EB22BD1-B8B1-417D-8276-F475C2E190FF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {0EB22BD1-B8B1-417D-8276-F475C2E190FF}.Release|Any CPU.Build.0 = Release|Any CPU
+ {3636D3E2-E3EF-4815-B020-819F382204CD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {3636D3E2-E3EF-4815-B020-819F382204CD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {3636D3E2-E3EF-4815-B020-819F382204CD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {3636D3E2-E3EF-4815-B020-819F382204CD}.Release|Any CPU.Build.0 = Release|Any CPU
+ {B9843F65-262E-4F40-A0BC-2CBEF7563A44}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {B9843F65-262E-4F40-A0BC-2CBEF7563A44}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {B9843F65-262E-4F40-A0BC-2CBEF7563A44}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {B9843F65-262E-4F40-A0BC-2CBEF7563A44}.Release|Any CPU.Build.0 = Release|Any CPU
+ {952808C5-799A-4CAA-964C-2AA78458CEC7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {952808C5-799A-4CAA-964C-2AA78458CEC7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {952808C5-799A-4CAA-964C-2AA78458CEC7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {952808C5-799A-4CAA-964C-2AA78458CEC7}.Release|Any CPU.Build.0 = Release|Any CPU
+ {03607817-6800-40B6-BEAA-D6F437CD62B7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {03607817-6800-40B6-BEAA-D6F437CD62B7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {03607817-6800-40B6-BEAA-D6F437CD62B7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {03607817-6800-40B6-BEAA-D6F437CD62B7}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
@@ -1014,6 +1084,7 @@ Global
{B501A547-C911-4A05-AC6E-274A50DFF30E} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{50D26304-0961-4A51-ABF6-6CAD1A56D203} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{4462B57A-7245-4146-B504-D46FDE762948} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
+ {1AF3672A-C5F1-4604-B6AB-D98C4DE9C3B1} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{B2C33A93-DB30-4099-903E-77D75C4C3F45} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{28026D16-EB0C-40B0-BDA7-11CAA2B97CCC} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{50D26304-0961-4A51-ABF6-6CAD1A56D202} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
@@ -1113,7 +1184,7 @@ Global
{E8F0BAA5-7327-43D1-9A51-644E81AE55F1} = {C65C6143-BED3-46E6-869E-9F0BE6E84C37}
{54E08BF5-F819-404F-A18D-0AB9EA81EA04} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
{AD6F474E-E6D4-4217-91F3-B7AF1BE31CCC} = {A41D1B99-F489-4C43-BBDF-96D61B19A6B9}
- {43026D51-3083-4850-928D-07E1883D5B1A} = {3F40F71B-7DCF-44A1-B15C-38CA34824143}
+ {43026D51-3083-4850-928D-07E1883D5B1A} = {C52D8057-43AF-40E6-A01B-6CDBB7301985}
{A88AB44F-7F9D-43F6-A127-83BB65E5A7E2} = {CC126D03-7EAC-493F-B187-DCDEE1EF6A70}
{E5A55C16-A5B9-4874-9043-A5266DC02F58} = {CC126D03-7EAC-493F-B187-DCDEE1EF6A70}
{3BED15FD-D608-4573-B432-1569C1026F6D} = {CC126D03-7EAC-493F-B187-DCDEE1EF6A70}
@@ -1131,7 +1202,6 @@ Global
{9C0660D9-48CA-40E1-BABA-8F6A1F11FE10} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
{21A01C2D-2501-4619-8144-48977DD22D9C} = {38940C5F-97FD-4B2A-B2CD-C4E4EF601B05}
{3F2FDC1C-DC6F-44CB-B4A1-A9026F25D66E} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
- {57557F32-0635-421A-BCF8-549AED50F764} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
{3DFB4701-E3D6-4435-9F70-A6E35822C4F2} = {EE97CB90-33BB-4F3A-9B3D-69375DEC6AC6}
{69F853E5-BD04-4842-984F-FC68CC51F402} = {8DBA5174-B0AA-4561-82B1-A46607697753}
{6FC8E6F5-659C-424D-AEB5-331B95883E29} = {998CAFE8-06E4-4683-A151-0F6AA4BFF6C6}
@@ -1159,8 +1229,21 @@ Global
{037F06F0-3BE8-42D0-801E-2F74FC380AB8} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
{18BDB5D5-340B-4834-B4FC-0327729A4A26} = {C2D1346B-9665-4150-B644-075CF1636BAA}
{5FE910A9-E7C9-40E1-AAF1-6C6C7DD61B67} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
- {B2B261E8-56EC-45DC-8AB8-A491A065EFD4} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
{2F11618A-9251-4609-B3D5-CE4D2B3D3E49} = {5CA5F70E-0FDB-467B-B22C-3CD5994F0087}
+ {764D2C19-0187-4837-A2A3-96DDC6EF4CE2} = {CC126D03-7EAC-493F-B187-DCDEE1EF6A70}
+ {9860FCF7-3111-4C12-A16F-ACEBA42D930F} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
+ {9102ECF3-5CD1-4107-B8B7-F3795A52D790} = {C52D8057-43AF-40E6-A01B-6CDBB7301985}
+ {50CF5D8F-F82F-4210-A06E-37CC9BFFDD49} = {C52D8057-43AF-40E6-A01B-6CDBB7301985}
+ {CFA94A39-4805-456D-A369-FC35CCC170E9} = {C52D8057-43AF-40E6-A01B-6CDBB7301985}
+ {C52D8057-43AF-40E6-A01B-6CDBB7301985} = {3F40F71B-7DCF-44A1-B15C-38CA34824143}
+ {4A490CBC-37F4-4859-AFDB-4B0833D144AF} = {38940C5F-97FD-4B2A-B2CD-C4E4EF601B05}
+ {34E868E9-D30B-4FB5-BC61-AFC4A9612A0F} = {EE97CB90-33BB-4F3A-9B3D-69375DEC6AC6}
+ {BE25E872-1667-4649-9D19-96B83E75A44E} = {8DBA5174-B0AA-4561-82B1-A46607697753}
+ {0EB22BD1-B8B1-417D-8276-F475C2E190FF} = {BE25E872-1667-4649-9D19-96B83E75A44E}
+ {3636D3E2-E3EF-4815-B020-819F382204CD} = {BE25E872-1667-4649-9D19-96B83E75A44E}
+ {B9843F65-262E-4F40-A0BC-2CBEF7563A44} = {C52D8057-43AF-40E6-A01B-6CDBB7301985}
+ {952808C5-799A-4CAA-964C-2AA78458CEC7} = {BE25E872-1667-4649-9D19-96B83E75A44E}
+ {03607817-6800-40B6-BEAA-D6F437CD62B7} = {BE25E872-1667-4649-9D19-96B83E75A44E}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {604E6B91-7BC0-4126-AE07-D4D2FEFC3D29}
diff --git a/SourceBuild.sln b/SourceBuild.sln
index 931e2d37384a7..71d7b261583f7 100644
--- a/SourceBuild.sln
+++ b/SourceBuild.sln
@@ -8,30 +8,26 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Compilers", "Compilers", "{
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{5DC491BA-E836-47C1-A4AA-3C770742718B}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeAnalysis", "src\Compilers\Core\Portable\CodeAnalysis.csproj", "{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis", "src\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj", "{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CSharp", "CSharp", "{9EECE6A3-C098-44D0-8ACD-0D8691EC8C3F}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CSharpCodeAnalysis", "src\Compilers\CSharp\Portable\CSharpCodeAnalysis.csproj", "{B501A547-C911-4A05-AC6E-274A50DFF30E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp", "src\Compilers\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.csproj", "{B501A547-C911-4A05-AC6E-274A50DFF30E}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "VisualBasic", "VisualBasic", "{11F63FDD-6EB7-4993-8769-8C8DC5DA29C3}"
EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "BasicCodeAnalysis", "src\Compilers\VisualBasic\Portable\BasicCodeAnalysis.vbproj", "{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}"
+Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic", "src\Compilers\VisualBasic\Portable\Microsoft.CodeAnalysis.VisualBasic.vbproj", "{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "csc", "src\Compilers\CSharp\csc\csc.csproj", "{E3CD2895-76A8-4D11-A316-EA67CB5EA42C}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "vbc", "src\Compilers\VisualBasic\vbc\vbc.csproj", "{8CE3A581-2969-4864-A803-013E9D977C3A}"
EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MSBuildTask", "src\Compilers\Core\MSBuildTask\MSBuildTask.csproj", "{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Build.Tasks.CodeAnalysis", "src\Compilers\Core\MSBuildTask\Microsoft.Build.Tasks.CodeAnalysis.csproj", "{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VBCSCompiler", "src\Compilers\Server\VBCSCompiler\VBCSCompiler.csproj", "{649CE05A-529C-40D7-A501-CA9BCFEE40DC}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Server", "Server", "{B57E7F86-EB16-4F60-A47C-F9D170F54400}"
EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tools", "Tools", "{CF8C8A40-B634-493D-9070-3319698BC280}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NuGetProjectPackUtil", "src\NuGet\NuGetProjectPackUtil.csproj", "{1D59AF1F-972B-423C-AEF3-2003E1BB1B43}"
-EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -44,76 +40,76 @@ Global
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|x64.ActiveCfg = Debug|x64
- {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|x64.Build.0 = Debug|x64
- {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|x86.ActiveCfg = Debug|x86
- {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|x86.Build.0 = Debug|x86
+ {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|x64.Build.0 = Debug|Any CPU
+ {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Debug|x86.Build.0 = Debug|Any CPU
{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|Any CPU.ActiveCfg = Release|Any CPU
{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|Any CPU.Build.0 = Release|Any CPU
- {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|x64.ActiveCfg = Release|x64
- {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|x64.Build.0 = Release|x64
- {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|x86.ActiveCfg = Release|x86
- {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|x86.Build.0 = Release|x86
+ {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|x64.ActiveCfg = Release|Any CPU
+ {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|x64.Build.0 = Release|Any CPU
+ {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|x86.ActiveCfg = Release|Any CPU
+ {1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}.Release|x86.Build.0 = Release|Any CPU
{B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|x64.ActiveCfg = Debug|x64
- {B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|x64.Build.0 = Debug|x64
- {B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|x86.ActiveCfg = Debug|x86
- {B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|x86.Build.0 = Debug|x86
+ {B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|x64.Build.0 = Debug|Any CPU
+ {B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {B501A547-C911-4A05-AC6E-274A50DFF30E}.Debug|x86.Build.0 = Debug|Any CPU
{B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|Any CPU.ActiveCfg = Release|Any CPU
{B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|Any CPU.Build.0 = Release|Any CPU
- {B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|x64.ActiveCfg = Release|x64
- {B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|x64.Build.0 = Release|x64
- {B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|x86.ActiveCfg = Release|x86
- {B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|x86.Build.0 = Release|x86
+ {B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|x64.ActiveCfg = Release|Any CPU
+ {B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|x64.Build.0 = Release|Any CPU
+ {B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|x86.ActiveCfg = Release|Any CPU
+ {B501A547-C911-4A05-AC6E-274A50DFF30E}.Release|x86.Build.0 = Release|Any CPU
{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|x64.ActiveCfg = Debug|x64
- {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|x64.Build.0 = Debug|x64
- {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|x86.ActiveCfg = Debug|x86
- {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|x86.Build.0 = Debug|x86
+ {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|x64.Build.0 = Debug|Any CPU
+ {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Debug|x86.Build.0 = Debug|Any CPU
{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|Any CPU.ActiveCfg = Release|Any CPU
{2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|Any CPU.Build.0 = Release|Any CPU
- {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|x64.ActiveCfg = Release|x64
- {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|x64.Build.0 = Release|x64
- {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|x86.ActiveCfg = Release|x86
- {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|x86.Build.0 = Release|x86
+ {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|x64.ActiveCfg = Release|Any CPU
+ {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|x64.Build.0 = Release|Any CPU
+ {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|x86.ActiveCfg = Release|Any CPU
+ {2523D0E6-DF32-4A3E-8AE0-A19BFFAE2EF6}.Release|x86.Build.0 = Release|Any CPU
{E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|x64.ActiveCfg = Debug|x64
- {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|x64.Build.0 = Debug|x64
- {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|x86.ActiveCfg = Debug|x86
- {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|x86.Build.0 = Debug|x86
+ {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|x64.Build.0 = Debug|Any CPU
+ {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Debug|x86.Build.0 = Debug|Any CPU
{E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|Any CPU.ActiveCfg = Release|Any CPU
{E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|Any CPU.Build.0 = Release|Any CPU
- {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|x64.ActiveCfg = Release|x64
- {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|x64.Build.0 = Release|x64
- {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|x86.ActiveCfg = Release|x86
- {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|x86.Build.0 = Release|x86
+ {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|x64.ActiveCfg = Release|Any CPU
+ {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|x64.Build.0 = Release|Any CPU
+ {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|x86.ActiveCfg = Release|Any CPU
+ {E3CD2895-76A8-4D11-A316-EA67CB5EA42C}.Release|x86.Build.0 = Release|Any CPU
{8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|x64.ActiveCfg = Debug|x64
- {8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|x64.Build.0 = Debug|x64
- {8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|x86.ActiveCfg = Debug|x86
- {8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|x86.Build.0 = Debug|x86
+ {8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|x64.Build.0 = Debug|Any CPU
+ {8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {8CE3A581-2969-4864-A803-013E9D977C3A}.Debug|x86.Build.0 = Debug|Any CPU
{8CE3A581-2969-4864-A803-013E9D977C3A}.Release|Any CPU.ActiveCfg = Release|Any CPU
{8CE3A581-2969-4864-A803-013E9D977C3A}.Release|Any CPU.Build.0 = Release|Any CPU
- {8CE3A581-2969-4864-A803-013E9D977C3A}.Release|x64.ActiveCfg = Release|x64
- {8CE3A581-2969-4864-A803-013E9D977C3A}.Release|x64.Build.0 = Release|x64
- {8CE3A581-2969-4864-A803-013E9D977C3A}.Release|x86.ActiveCfg = Release|x86
- {8CE3A581-2969-4864-A803-013E9D977C3A}.Release|x86.Build.0 = Release|x86
+ {8CE3A581-2969-4864-A803-013E9D977C3A}.Release|x64.ActiveCfg = Release|Any CPU
+ {8CE3A581-2969-4864-A803-013E9D977C3A}.Release|x64.Build.0 = Release|Any CPU
+ {8CE3A581-2969-4864-A803-013E9D977C3A}.Release|x86.ActiveCfg = Release|Any CPU
+ {8CE3A581-2969-4864-A803-013E9D977C3A}.Release|x86.Build.0 = Release|Any CPU
{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|x64.ActiveCfg = Debug|x64
- {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|x64.Build.0 = Debug|x64
- {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|x86.ActiveCfg = Debug|x86
- {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|x86.Build.0 = Debug|x86
+ {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|x64.Build.0 = Debug|Any CPU
+ {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Debug|x86.Build.0 = Debug|Any CPU
{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|Any CPU.ActiveCfg = Release|Any CPU
{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|Any CPU.Build.0 = Release|Any CPU
- {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|x64.ActiveCfg = Release|x64
- {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|x64.Build.0 = Release|x64
- {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|x86.ActiveCfg = Release|x86
- {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|x86.Build.0 = Release|x86
+ {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|x64.ActiveCfg = Release|Any CPU
+ {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|x64.Build.0 = Release|Any CPU
+ {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|x86.ActiveCfg = Release|Any CPU
+ {7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3}.Release|x86.Build.0 = Release|Any CPU
{649CE05A-529C-40D7-A501-CA9BCFEE40DC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{649CE05A-529C-40D7-A501-CA9BCFEE40DC}.Debug|Any CPU.Build.0 = Debug|Any CPU
{649CE05A-529C-40D7-A501-CA9BCFEE40DC}.Debug|x64.ActiveCfg = Debug|Any CPU
@@ -126,18 +122,9 @@ Global
{649CE05A-529C-40D7-A501-CA9BCFEE40DC}.Release|x64.Build.0 = Release|Any CPU
{649CE05A-529C-40D7-A501-CA9BCFEE40DC}.Release|x86.ActiveCfg = Release|Any CPU
{649CE05A-529C-40D7-A501-CA9BCFEE40DC}.Release|x86.Build.0 = Release|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Debug|x64.ActiveCfg = Debug|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Debug|x64.Build.0 = Debug|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Debug|x86.ActiveCfg = Debug|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Debug|x86.Build.0 = Debug|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Release|Any CPU.ActiveCfg = Release|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Release|Any CPU.Build.0 = Release|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Release|x64.ActiveCfg = Release|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Release|x64.Build.0 = Release|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Release|x86.ActiveCfg = Release|Any CPU
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43}.Release|x86.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{DDFAE591-7414-4CC9-AD99-427C2D153893} = {6D173F59-562E-4BAA-8D98-9A8F4901D99A}
@@ -152,7 +139,8 @@ Global
{7AD4FE65-9A30-41A6-8004-AA8F89BCB7F3} = {5DC491BA-E836-47C1-A4AA-3C770742718B}
{649CE05A-529C-40D7-A501-CA9BCFEE40DC} = {B57E7F86-EB16-4F60-A47C-F9D170F54400}
{B57E7F86-EB16-4F60-A47C-F9D170F54400} = {DDFAE591-7414-4CC9-AD99-427C2D153893}
- {CF8C8A40-B634-493D-9070-3319698BC280} = {DDFAE591-7414-4CC9-AD99-427C2D153893}
- {1D59AF1F-972B-423C-AEF3-2003E1BB1B43} = {CF8C8A40-B634-493D-9070-3319698BC280}
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {8157FCF4-7FB2-412F-883A-DC40977425EC}
EndGlobalSection
EndGlobal
diff --git a/THIRD-PARTY-NOTICES.txt b/THIRD-PARTY-NOTICES.txt
new file mode 100644
index 0000000000000..27c91a2ac498a
--- /dev/null
+++ b/THIRD-PARTY-NOTICES.txt
@@ -0,0 +1,25 @@
+Roslyn uses third-party libraries or other resources that may be
+distributed under licenses different than the Roslyn software.
+
+In the event that we accidentally failed to list a required notice, please
+bring it to our attention. Post an issue or email us:
+
+ dotnet@microsoft.com
+
+The attached notices are provided for information only.
+
+License notice for .NET Core Libraries (CoreFX)
+-------------------------------------
+
+https://github.com/dotnet/corefx
+
+Copyright (c) 2018 .NET Foundation and Contributors
+
+This software is licensed subject to the MIT license, available at
+https://opensource.org/licenses/MIT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/build.sh b/build.sh
index 9cdfb2e19c051..03eeff0ad74a1 100755
--- a/build.sh
+++ b/build.sh
@@ -15,8 +15,7 @@ usage()
echo " --release Build Release"
echo " --restore Restore projects required to build"
echo " --build Build all projects"
- echo " --pack Build prerelease nuget packages"
- echo " --packall Build all nuget packages"
+ echo " --pack Build nuget packages"
echo " --test Run unit tests"
echo " --mono Run unit tests with mono"
echo " --build-bootstrap Build the bootstrap compilers"
@@ -35,7 +34,6 @@ restore=false
build=false
test_=false
pack=false
-pack_all=false
use_mono=false
build_bootstrap=false
use_bootstrap=false
@@ -100,10 +98,6 @@ do
--pack)
pack=true
;;
- --packall)
- pack_all=true
- pack=true
- ;;
*)
echo "$1"
usage
@@ -120,32 +114,6 @@ mkdir -p ${binaries_path}
mkdir -p ${config_path}
mkdir -p ${logs_path}
-function pack_all_kind() {
- pushd "${root_path}/src/NuGet"
-
- echo Packing $1
-
- local nupkg_path="${config_path}/NuGet/PreRelease"
- local nuspec_files=("Microsoft.CodeAnalysis.CSharp.nuspec" "Microsoft.CodeAnalysis.Compilers.nuspec" "Microsoft.CodeAnalysis.VisualBasic.nuspec" "Microsoft.CodeAnalysis.Common.nuspec" "Microsoft.NETCore.Compilers.nuspec")
- mkdir -p ${nupkg_path}
- for i in "${nuspec_files[@]}"
- do
- dotnet pack -nologo --no-build NuGetProjectPackUtil.csproj -p:NuSpecFile=$i -p:NuGetPackageKind=$1 -p:NuspecBasePath=${binaries_path}/Debug -o ${nupkg_path}
- done
-
- popd
-}
-
-function pack_all() {
- pack_all_kind PreRelease
-
- if [[ "$pack_all" = true ]]
- then
- pack_all_kind Release
- pack_all_kind PerBuildPreRelease
- fi
-}
-
function stop_processes {
echo "Killing running build processes..."
pkill -9 "dotnet" || true
@@ -164,32 +132,29 @@ source "${root_path}"/build/scripts/obtain_dotnet.sh
if [[ "$restore" == true ]]
then
echo "Restoring RoslynToolset.csproj"
- dotnet restore "${root_path}/build/ToolsetPackages/RoslynToolset.csproj" /bl:${logs_path}/Restore-RoslynToolset.binlog
+ dotnet restore "${root_path}/build/ToolsetPackages/RoslynToolset.csproj" "/bl:${logs_path}/Restore-RoslynToolset.binlog"
echo "Restoring Compilers.sln"
- dotnet restore "${root_path}/Compilers.sln" /bl:${logs_path}/Restore-Compilers.binlog
+ dotnet restore "${root_path}/Compilers.sln" "/bl:${logs_path}/Restore-Compilers.binlog"
fi
build_args="--no-restore -c ${build_configuration} /nologo"
if [[ "$build_bootstrap" == true ]]
then
- echo "Building bootstrap toolset"
- bootstrap_build_args="${build_args} /p:UseShippingAssemblyVersion=true /p:InitialDefineConstants=BOOTSTRAP"
- bootstrap_files=( 'src/Compilers/CSharp/csc/csc.csproj' 'src/Compilers/VisualBasic/vbc/vbc.csproj' 'src/Compilers/Server/VBCSCompiler/VBCSCompiler.csproj' 'src/Compilers/Core/MSBuildTask/MSBuildTask.csproj')
- for bootstrap_file in "${bootstrap_files[@]}"
- do
- bootstrap_name=$(basename $bootstrap_file)
- dotnet publish "${bootstrap_file}" --framework netcoreapp2.0 ${bootstrap_build_args} "/bl:${binaries_path}/${bootstrap_name}.binlog"
- done
+ echo "Building bootstrap compiler"
rm -rf ${bootstrap_path}
mkdir -p ${bootstrap_path}
- dotnet pack -nologo src/NuGet/NuGetProjectPackUtil.csproj -p:NuSpecFile=Microsoft.NETCore.Compilers.nuspec -p:NuGetPackageKind=Bootstrap -p:NuspecBasePath=${binaries_path}/Debug -o ${bootstrap_path}
- mkdir -p ${bootstrap_path}/microsoft.netcore.compilers
- unzip ${bootstrap_path}/Microsoft.NETCore.Compilers.42.42.42.42-bootstrap.nupkg -d ${bootstrap_path}/microsoft.netcore.compilers/42.42.42.42
- chmod -R 755 ${bootstrap_path}/microsoft.netcore.compilers
- dotnet clean Compilers.sln
+ project_path=src/NuGet/Microsoft.NETCore.Compilers/Microsoft.NETCore.Compilers.Package.csproj
+
+ dotnet pack -nologo ${project_path} /p:DotNetUseShippingVersions=true /p:InitialDefineConstants=BOOTSTRAP /p:PackageOutputPath=${bootstrap_path}
+ unzip ${bootstrap_path}/Microsoft.NETCore.Compilers.*.nupkg -d ${bootstrap_path}
+ chmod -R 755 ${bootstrap_path}
+
+ echo "Cleaning Bootstrap compiler artifacts"
+ dotnet clean ${project_path}
+
stop_processes
fi
@@ -208,20 +173,20 @@ fi
if [[ "${build}" == true ]]
then
echo "Building Compilers.sln"
- dotnet build "${root_path}"/Compilers.sln ${build_args} "/bl:${binaries_path}/Build.binlog"
-fi
-if [[ "${pack}" == true ]]
-then
- pack_all
+ if [[ "${pack}" == true ]]
+ then
+ build_args+=" /t:Pack"
+ fi
+
+ dotnet build "${root_path}/Compilers.sln" ${build_args} "/bl:${binaries_path}/Build.binlog"
fi
if [[ "${stop_vbcscompiler}" == true ]]
then
if [[ "${use_bootstrap}" == true ]]
then
- echo "Stopping VBCSCompiler"
- dotnet "${bootstrap_path}"/microsoft.netcore.compilers/42.42.42.42/tools/bincore/VBCSCompiler.dll -shutdown
+ dotnet build-server shutdown
else
echo "--stop-vbcscompiler requires --use-bootstrap. Aborting."
exit 1
diff --git a/build/Rulesets/NonShippingProject_BuildRules.ruleset b/build/Rulesets/NonShippingProject_BuildRules.ruleset
index e0f85cc19556d..13aa8aaf23b30 100644
--- a/build/Rulesets/NonShippingProject_BuildRules.ruleset
+++ b/build/Rulesets/NonShippingProject_BuildRules.ruleset
@@ -35,12 +35,12 @@
-
+
-
-
\ No newline at end of file
+
+
diff --git a/build/Rulesets/Roslyn_BuildRules.ruleset b/build/Rulesets/Roslyn_BuildRules.ruleset
index c7a1904233865..b6abab47bbd5f 100644
--- a/build/Rulesets/Roslyn_BuildRules.ruleset
+++ b/build/Rulesets/Roslyn_BuildRules.ruleset
@@ -47,6 +47,7 @@
+
@@ -153,4 +154,16 @@
collection.
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/Strong Name Keys/RoslynInternalKey.Private.snk b/build/Strong Name Keys/RoslynInternalKey.Private.snk
deleted file mode 100644
index 481444ab8387f..0000000000000
Binary files a/build/Strong Name Keys/RoslynInternalKey.Private.snk and /dev/null differ
diff --git a/build/Strong Name Keys/RoslynInternalKey.Public.snk b/build/Strong Name Keys/RoslynInternalKey.Public.snk
deleted file mode 100644
index cac0aecd8d15a..0000000000000
Binary files a/build/Strong Name Keys/RoslynInternalKey.Public.snk and /dev/null differ
diff --git a/build/Targets/BeforeCommonTargets.targets b/build/Targets/BeforeCommonTargets.targets
index 86e49d8e60b84..70b18cf850cfd 100644
--- a/build/Targets/BeforeCommonTargets.targets
+++ b/build/Targets/BeforeCommonTargets.targets
@@ -13,6 +13,7 @@
<_NeedRuntimeAssets>true
true
$(OutputPath)UnitTests\$(MSBuildProjectName)\
+ false
@@ -67,13 +68,13 @@
$(OutputPath)$(RuntimeIdentifier)\$(PublishDirName)\
$(OutputPath)$(TargetFramework)\$(PublishDirName)\
- $(AssemblyName).xml
+ $(AssemblyName).xml
$(IntermediateOutputPath)$(TargetFramework.ToLowerInvariant())\
- $(OutputPath)$(TargetFramework.ToLowerInvariant())\
- $(IntermediateOutputPath)$(AssemblyName).xml
+ $(OutputPath)$(TargetFramework.ToLowerInvariant())\
+ $(IntermediateOutputPath)$(AssemblyName).xml
@@ -94,7 +95,7 @@
- $(MSBuildThisFileDirectory)..\Rulesets\NonShippingProject$(DefaultRulesetSuffix).ruleset
+ $(MSBuildThisFileDirectory)..\Rulesets\NonShippingProject$(DefaultRulesetSuffix).ruleset
$(MSBuildThisFileDirectory)..\Rulesets\AnalyzerProject$(DefaultRulesetSuffix).ruleset
$(MSBuildThisFileDirectory)..\Rulesets\Roslyn$(DefaultRulesetSuffix).ruleset
diff --git a/build/Targets/DisableStandardFrameworkResolution.targets b/build/Targets/DisableStandardFrameworkResolution.targets
deleted file mode 100644
index d55b0b31f3c8a..0000000000000
--- a/build/Targets/DisableStandardFrameworkResolution.targets
+++ /dev/null
@@ -1,21 +0,0 @@
-
-
-
-
-
- $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
-
-
-
-
-
-
- <_TargetFrameworkDirectories />
-
-
-
-
- true
-
-
-
\ No newline at end of file
diff --git a/build/Targets/DisableVsixManifestTargets.targets b/build/Targets/DisableVsixManifestTargets.targets
deleted file mode 100644
index 5f02c50bc4fb8..0000000000000
--- a/build/Targets/DisableVsixManifestTargets.targets
+++ /dev/null
@@ -1,12 +0,0 @@
-
-
-
-
-
- $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
-
-
-
-
-
-
diff --git a/build/Targets/GenerateAssemblyInfo.targets b/build/Targets/GenerateAssemblyInfo.targets
deleted file mode 100644
index 8f5b3f10cc5f3..0000000000000
--- a/build/Targets/GenerateAssemblyInfo.targets
+++ /dev/null
@@ -1,101 +0,0 @@
-
-
-
-
-
- $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
-
-
-
- $(IntermediateOutputPath)GeneratedAssemblyInfo_$(BuildVersion)$(DefaultLanguageSourceExtension)
-
-
-
-
- <_Parameter1>$(Company)
-
-
- <_Parameter1>$(Copyright)
-
-
- <_Parameter1>$(AssemblyVersion)
-
-
- <_Parameter1>$(BuildVersion)
-
-
- <_Parameter1>$(InformationalVersion)
-
-
-
-
-
- GenerateAssemblyInfoFile;$(CoreCompileDependsOn)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- <_Parameter1 Condition="'$(OfficialBuild)' == 'true'">$(SourceRevisionId)
- <_Parameter1 Condition="'$(OfficialBuild)' != 'true'"><developer build>
-
-
-
-
diff --git a/build/Targets/GenerateCompilerExecutableBindingRedirects.targets b/build/Targets/GenerateCompilerExecutableBindingRedirects.targets
index 9141f1ddc3996..c53025d6cadde 100644
--- a/build/Targets/GenerateCompilerExecutableBindingRedirects.targets
+++ b/build/Targets/GenerateCompilerExecutableBindingRedirects.targets
@@ -13,58 +13,62 @@
true
-
-
-
- $(AssemblyVersion)
-
-
- $(AssemblyVersion)
-
-
- $(AssemblyVersion)
-
-
- 1.2.3.0
-
-
- 4.0.1.0
-
-
- 4.0.1.0
-
-
- 4.0.3.0
-
-
- 4.1.2.0
-
-
- 4.0.2.0
-
-
- 4.0.2.0
-
-
- 4.0.1.0
-
-
- 1.4.3.0
-
-
- 4.0.1.0
-
-
- 4.0.1.0
-
-
- 4.0.1.0
-
-
- 4.0.1.0
-
-
- 4.1.0.0
-
-
+
+
+
+
+
+
+ $(AssemblyVersion)
+
+
+ $(AssemblyVersion)
+
+
+ $(AssemblyVersion)
+
+
+ 1.2.3.0
+
+
+ 4.0.1.0
+
+
+ 4.0.1.0
+
+
+ 4.0.3.0
+
+
+ 4.1.2.0
+
+
+ 4.0.2.0
+
+
+ 4.0.2.0
+
+
+ 4.0.1.0
+
+
+ 1.4.3.0
+
+
+ 4.0.1.0
+
+
+ 4.0.1.0
+
+
+ 4.0.1.0
+
+
+ 4.0.1.0
+
+
+ 4.1.0.0
+
+
+
\ No newline at end of file
diff --git a/build/Targets/GenerateInternalsVisibleTo.targets b/build/Targets/GenerateInternalsVisibleTo.targets
deleted file mode 100644
index 314934fd842c2..0000000000000
--- a/build/Targets/GenerateInternalsVisibleTo.targets
+++ /dev/null
@@ -1,140 +0,0 @@
-
-
-
-
-
- $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
-
-
-
- $(IntermediateOutputPath)GeneratedInternalsVisibleTo$(DefaultLanguageSourceExtension)
-
-
-
- GenerateInternalsVisibleToFile;$(CoreCompileDependsOn)
-
-
-
-
- false
-
-
- false
-
-
- false
-
-
- false
-
-
- false
-
-
- false
-
-
- false
-
-
- false
-
-
- false
-
-
- false
-
-
-
-
- , PublicKey=$(RoslynPublicKey)
- , PublicKey=$(RoslynInternalKey)
- , PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7
- , PublicKey=002400000c800000940000000602000000240000525341310004000001000100e1290d741888d13312c0cd1f72bb843236573c80158a286f11bb98de5ee8acc3142c9c97b472684e521ae45125d7414558f2e70ac56504f3e8fe80830da2cdb1cda8504e8d196150d05a214609234694ec0ebf4b37fc7537e09d877c3e65000f7467fa3adb6e62c82b10ada1af4a83651556c7d949959817fed97480839dd39b
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/build/Targets/Imports.targets b/build/Targets/Imports.targets
index 42bd99da797b0..ef352fe2e102d 100644
--- a/build/Targets/Imports.targets
+++ b/build/Targets/Imports.targets
@@ -6,66 +6,22 @@
$(MSBuildAllProjects);$(MSBuildThisFileFullPath)
-
-
-
+
+
- 0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9
- 002400000480000094000000060200000024000052534131000400000100010055e0217eb635f69281051f9a823e0c7edd90f28063eb6c7a742a19b4f6139778ee0af438f47aed3b6e9f99838aa8dba689c7a71ddb860c96d923830b57bbd5cd6119406ddb9b002cf1c723bf272d6acbb7129e9d6dd5a5309c94e0ff4b2c884d45a55f475cd7dba59198086f61f5a8c8b5e601c0edbf269733f6f578fc8579c2
-
512
- true
- True
false
- $(MSBuildToolsPath)\Microsoft.$(MSBuildTargetsLanguageName).targets
-
-
- true
+
+ $(ArtifactsConfigurationDir)DevDivPackages\Roslyn\
-
-
-
-
-
-
-
-
-
-
- $(MSBuildThisFileDirectory)..\Strong Name Keys\35MSSharedLib1024.snk
- $(RoslynPublicKey)
- 31BF3856AD364E35
- true
-
-
-
-
-
-
- $(MSBuildThisFileDirectory)..\Strong Name Keys\RoslynInternalKey.Private.snk
- false
- $(RoslynInternalKey)
- fc793a00266884fb
-
-
-
- true
-
-
-
-
-
-
-
+
<_ExplicitReference Include="$(FrameworkPathOverride)\mscorlib.dll" />
@@ -100,10 +56,20 @@
-
-
-
-
+
+
+
+
+ <_Parameter1 Condition="'$(OfficialBuild)' == 'true'">$(SourceRevisionId)
+ <_Parameter1 Condition="'$(OfficialBuild)' != 'true'"><developer build>
+
+
+
RestoreToolsetCheck;$(PrepareForBuildDependsOn)
@@ -113,8 +79,6 @@
-
-
-
-
-
-
-
-
-
-
-
- false
-
-
-
+
+
+
+
+
-
+ This target is used to copy referenced projects to a sub-directory vs. the direct output
+ directory of the build. Useful when the referenced project is an EXE and the referencing
+ project uses an incompatible TargetFramework (e.g. CommandLineTest -> csc/vbc)
+ -->
+
<_RoslynReferenceOutputPath>@(RoslynReferenceToDependencyDirectory->'%(RootDir)%(Directory)')
@@ -197,10 +137,12 @@
-
+
@@ -225,7 +167,7 @@
In official build the content of ArtifactsSymStoreDirectory is uploaded to a symbol server.
-->
- false
+ false
+ Condition="'$(IsShipping)' == 'true'" />
+
+
+
+
+
+
+
+
+
+
+ $(PackageDescription)
+ More details at https://aka.ms/roslyn-packages
+ This package was built from the source at $(PrivateRepositoryUrl)/commit/$(SourceRevisionId).
+
+
+
+
+
+
+
+
+
+
+
+ true
+ false
+ false
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/Targets/PackageProject.targets b/build/Targets/PackageProject.targets
new file mode 100644
index 0000000000000..3326b7d9aae51
--- /dev/null
+++ b/build/Targets/PackageProject.targets
@@ -0,0 +1,22 @@
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+
+
+
+
+ false
+
+
\ No newline at end of file
diff --git a/build/Targets/Packages.props b/build/Targets/Packages.props
index eeb05ce3b8880..1130f69a0e989 100644
--- a/build/Targets/Packages.props
+++ b/build/Targets/Packages.props
@@ -6,37 +6,50 @@
$(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+ 2.11.0
+ beta1
+ true
+
+
+ $(VersionPrefix).0
+
+
+
+
+
+ 2.6.2-beta2
+
0.9.3
+ 0.11.0
2.0.273-beta
- 8.0.1
+ 8.0.2
8.0.0
- 2.3.1
0.9.2
2.2.0
- 3.1.0.3652
- 0.22.0
+ 4.0.0.4285-beta1
0.2.0
1.0.0
1.0.422
- 2.0.6
15.1.0-preview-000458-02
15.1.0-preview-000458-02
- 1.1.224
1.0.13
15.1.0-preview-000458-02
15.1.0-preview-000458-02
- 2.6.1
+ $(RoslynDiagnosticsNugetPackageVersion)
2.0.0-rc2-61102-09
- 1.0.1
- 1.0.1
- 1.0.1
- 1.0.1
0.10.6
2.0.12
- 1.0.1
- 1.0.1
- 1.0.1
+ $(RoslynDiagnosticsNugetPackageVersion)
1.0.31
4.3.0
0.8.31-beta
@@ -49,15 +62,14 @@
4.7.2-alpha-00001
1.0.27-prerelease-01811-02
2.1.0-prerelease-02419-02
+ 1.0.0-beta.18455.10
3.13.8
- 15.0.26730-alpha
+ 15.8.27812-alpha
14.3.25407-alpha
1.0.0-beta1-63011-01
8.0.0.0-alpha
-
- 15.6.0-dev
2.9.0-beta7-63018-03
- 2.6.1-beta1-62824-01
+ $(RoslynDiagnosticsNugetPackageVersion)
2.0.0
2.9.0-beta7-63018-03
5.0.0
@@ -70,97 +82,92 @@
2.0.0-alpha-20170405-2
0.1.0
0.1.2-dev
- 1.1.122-rc
- 1.0.0-beta-63001-01
+ 1.3.23
+ 1.0.0-beta-63201-01
+ 1.0.0-beta-63008-01
4.5.24
10.1.0
- 15.0.26730-alpha
- 15.0.26730-alpha
+ 15.8.27812-alpha
+ 15.8.27812-alpha
1.1.20180503.2
- 15.0.26730-alpha
+ 15.7.27703
15.5.23
- 15.8.238-preview
+ 15.8.414-preview
15.0.27309-vsucorediag
15.0.27309-vsucorediag
15.0.27309-vsucorediag
- 10.0.30319
1.1.4322
- 15.0.26730-alpha
- 15.8.238-preview
- 15.0.26730-alpha
+ 15.8.27812-alpha
+ 15.0.17
+ 15.8.414-preview
+ 15.8.27812-alpha
15.0.26730-alpha
- 15.0.26730-alpha
+ 15.8.27828
2.0.0-rc3-61304-01
- 15.3.1710.203
- 15.8.238-preview
- 15.8.238-preview
- 15.8.238-preview
- 7.10.6070
- 15.8.238-preview
- 15.0.26730-alpha
- 15.0.26730-alpha
- 15.0.26730-alpha
+ 15.8.414-preview
+ 15.8.27812-alpha
+ 15.8.414-preview
+ 15.8.414-preview
+ 15.8.414-preview
+ 7.10.6071
+ 15.8.414-preview
+ 15.8.27812-alpha
+ 15.8.27812-alpha
+ 15.8.27812-alpha
15.3.178-pre-g209fb07c2e
2.3.6152103
- 10.0.0.0-alpha
14.0.249-master2E2DC10C
+ 15.7.7
1.15.103
- 14.3.25407
- 14.3.25407
- 15.0.26730-alpha
- 15.0.26730-alpha
- 15.0.26730-alpha
- 15.0.26730-alpha
- 15.0.25413-Preview5
- 7.10.6071
- 10.0.30319
- 11.0.61030
+ 15.8.27828
+ 15.8.27828
+ 15.7.27703
+ 15.0.25415
+ 15.0.25415
+ 7.10.6072
+ 10.0.30320
+ 11.0.61031
12.1.30328
- 15.0.25726-Preview5
- 15.0.26730-alpha
- 15.0.26730-alpha
- 8.0.50727
- 9.0.30729
- 15.0.26730-alpha
+ 8.0.50728
+ 15.8.27812-alpha
8.0.0.0-alpha
- 15.8.238-preview
- 15.8.238-preview
- 15.8.238-preview
- 15.8.238-preview
- 15.8.238-preview
- 7.10.6070
- 10.0.30319
+ 15.8.414-preview
+ 15.8.414-preview
+ 15.8.414-preview
+ 15.8.414-preview
+ 15.8.414-preview
+ 7.10.6071
+ 10.0.30320
12.0.30110
12.1.30328
- 15.3.23
- 15.0.26730-alpha
+ 15.8.132
+ 15.8.99-rc
15.3.23
2.0.0-rc3-61304-01
4.3.0
+ 1.2.48
0.1.0
4.4.0
4.7.99
1.0.1
1.6.1
9.0.1
- 2.8.5
- 3.5.0-beta2-1484
4.0.0-rc-2048
- 1.4.2
- 0.23.0
1.1.0-beta1-62506-02
105.2.3
0.9.8-beta
- 2.11.0-beta1-63126-01
+ 2.11.0-beta1-63312-06
+ $(RoslynDiagnosticsNugetPackageVersion)
0.2.4-beta
- 0.4.0-beta
+ 1.0.0-beta2-63222-01
+ 1.0.0-beta2-63222-01
0.5.0-alpha
+ 1.0.0-beta2-63223-01
0.1.3
- 1.0.0-beta2-dev3
- 1.0.0-beta2-62731-01
+ 1.0.0-beta2-63217-01
4.3.0
0.0.4
- 1.1.92
+ 1.3.23
4.3.0
4.3.0
4.3.0
@@ -177,6 +184,7 @@
4.3.0
4.5.0
4.3.0
+ 4.3.0
5.0.0
4.3.0
4.3.0
@@ -211,6 +219,7 @@
4.3.0
4.3.0
4.3.0
+ 4.3.0
4.3.0
4.3.0
4.3.0
@@ -232,25 +241,94 @@
4.3.0
4.3.0
4.3.0
+ 4.3.0
4.3.0
1.1.2
1.1.0.14
15.8.68-develop-g109a00ff
- 7.0.3300
- 14.3.25407-alpha
- 7.0.5000
- 8.0.0.0-alpha
- 12.0.4
- 8.0.0.0-alpha
+ 7.0.3301
+ 14.0.25030
+ 7.0.5001
+ 8.0.50728
+ 8.0.50727
2.4.1
0.2.0-beta-63004-01
- 2.3.1
- 0.8.0
- 2.3.1
- 2.3.1
- 2.3.1
+ 2.4.1-pre.build.4059
+ 0.10.0
+ 2.4.1-pre.build.4059
+ 2.4.1-pre.build.4059
1.0.51
- 2.3.1
+ 2.4.1-pre.build.4059
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ true
+ true
+ true
+ true
@@ -276,6 +354,7 @@
https://myget.org/F/vs-editor/api/v3/index.json;
https://vside.myget.org/F/vssdk/api/v3/index.json;
https://vside.myget.org/F/vs-impl/api/v3/index.json;
+ https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json;
diff --git a/build/Strong Name Keys/35MSSharedLib1024.snk b/build/Targets/RepoToolset/35MSSharedLib1024.snk
similarity index 100%
rename from build/Strong Name Keys/35MSSharedLib1024.snk
rename to build/Targets/RepoToolset/35MSSharedLib1024.snk
diff --git a/build/Targets/RepoToolset/AfterSigning.proj b/build/Targets/RepoToolset/AfterSigning.proj
new file mode 100644
index 0000000000000..47b274f3ac6b7
--- /dev/null
+++ b/build/Targets/RepoToolset/AfterSigning.proj
@@ -0,0 +1,26 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/Targets/RepoToolset/AfterSolutionBuild.proj b/build/Targets/RepoToolset/AfterSolutionBuild.proj
new file mode 100644
index 0000000000000..d644ba1d627b5
--- /dev/null
+++ b/build/Targets/RepoToolset/AfterSolutionBuild.proj
@@ -0,0 +1,18 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/Targets/RepoToolset/BuildReleasePackages.targets b/build/Targets/RepoToolset/BuildReleasePackages.targets
new file mode 100644
index 0000000000000..c3258c73103fa
--- /dev/null
+++ b/build/Targets/RepoToolset/BuildReleasePackages.targets
@@ -0,0 +1,32 @@
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+ <_NuGetRepackAssembly Condition="'$(MSBuildRuntimeType)' != 'Core'">$(NuGetPackageRoot)roslyntools.nugetrepack.buildtasks\$(RoslynToolsNuGetRepackVersion)\tools\net461\RoslynTools.NuGetRepack.BuildTasks.dll
+ <_NuGetRepackAssembly Condition="'$(MSBuildRuntimeType)' == 'Core'">$(NuGetPackageRoot)roslyntools.nugetrepack.buildtasks\$(RoslynToolsNuGetRepackVersion)\tools\netcoreapp2.0\RoslynTools.NuGetRepack.BuildTasks.dll
+
+
+
+
+
+
+
+
+
+
+ <_BuiltPackages Include="$(ArtifactsShippingPackagesDir)*.nupkg" />
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/Targets/RepoToolset/BuildStep.props b/build/Targets/RepoToolset/BuildStep.props
new file mode 100644
index 0000000000000..064e50f3d088f
--- /dev/null
+++ b/build/Targets/RepoToolset/BuildStep.props
@@ -0,0 +1,5 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/BuildTasks.props b/build/Targets/RepoToolset/BuildTasks.props
index 2a933932f2668..67497365ea3d3 100644
--- a/build/Targets/RepoToolset/BuildTasks.props
+++ b/build/Targets/RepoToolset/BuildTasks.props
@@ -5,7 +5,7 @@
$(MSBuildAllProjects);$(MSBuildThisFileFullPath)
- $(NuGetPackageRoot)roslyntools.buildtasks\$(RoslynToolsBuildTasksVersion)\tools\net46\RoslynTools.BuildTasks.dll
- $(NuGetPackageRoot)roslyntools.buildtasks\$(RoslynToolsBuildTasksVersion)\tools\netcoreapp1.0\RoslynTools.BuildTasks.dll
+ $(NuGetPackageRoot)roslyntools.buildtasks\$(RoslynToolsBuildTasksVersion)\tools\net461\RoslynTools.BuildTasks.dll
+ $(NuGetPackageRoot)roslyntools.buildtasks\$(RoslynToolsBuildTasksVersion)\tools\netcoreapp2.0\RoslynTools.BuildTasks.dll
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/DefaultVersions.props b/build/Targets/RepoToolset/DefaultVersions.props
index 43065e8f20f52..e3ae34a57b0bd 100644
--- a/build/Targets/RepoToolset/DefaultVersions.props
+++ b/build/Targets/RepoToolset/DefaultVersions.props
@@ -6,6 +6,11 @@
$(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+ false
+ true
+
+
diff --git a/build/Targets/RepoToolset/GenerateInternalsVisibleTo.targets b/build/Targets/RepoToolset/GenerateInternalsVisibleTo.targets
new file mode 100644
index 0000000000000..3297a690bd9a3
--- /dev/null
+++ b/build/Targets/RepoToolset/GenerateInternalsVisibleTo.targets
@@ -0,0 +1,48 @@
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+ $(IntermediateOutputPath)$(MSBuildProjectName).InternalsVisibleTo$(DefaultLanguageSourceExtension)
+
+
+
+
+ false
+
+
+
+
+
+ <_InternalsVisibleToAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+ <_Parameter1 Condition="'%(InternalsVisibleTo.Key)' != ''">%(InternalsVisibleTo.Identity), PublicKey=%(InternalsVisibleTo.Key)
+ <_Parameter1 Condition="'%(InternalsVisibleTo.Key)' == ''">%(InternalsVisibleTo.Identity), PublicKey=$(PublicKey)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/Imports.targets b/build/Targets/RepoToolset/Imports.targets
new file mode 100644
index 0000000000000..3ddd52c47b153
--- /dev/null
+++ b/build/Targets/RepoToolset/Imports.targets
@@ -0,0 +1,38 @@
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+ true
+
+
+
+
+ true
+
+ $(ArtifactsShippingPackagesDir)
+ $(ArtifactsNonShippingPackagesDir)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/Localization.targets b/build/Targets/RepoToolset/Localization.targets
new file mode 100644
index 0000000000000..ffdcd850328ba
--- /dev/null
+++ b/build/Targets/RepoToolset/Localization.targets
@@ -0,0 +1,32 @@
+
+
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+ true
+
+
+ true
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/OptimizationData.targets b/build/Targets/RepoToolset/OptimizationData.targets
index 74587dd044282..8316e4122f362 100644
--- a/build/Targets/RepoToolset/OptimizationData.targets
+++ b/build/Targets/RepoToolset/OptimizationData.targets
@@ -43,7 +43,7 @@
A local build emulating an official build can pass /p:SkipApplyOptimizations=true to avoid this error.
-->
diff --git a/build/Targets/RepoToolset/ProjectDefaults.props b/build/Targets/RepoToolset/ProjectDefaults.props
new file mode 100644
index 0000000000000..2a725d6716517
--- /dev/null
+++ b/build/Targets/RepoToolset/ProjectDefaults.props
@@ -0,0 +1,147 @@
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+ true
+ MicrosoftShared
+ SHA256
+ true
+ en-US
+ Microsoft Corporation
+ © Microsoft Corporation. All rights reserved.
+ Microsoft
+ true
+ false
+ true
+ http://go.microsoft.com/fwlink/?LinkId=529443
+ true
+
+
+ true
+
+
+ false
+
+
+ full
+ portable
+ embedded
+
+
+
+ {TargetFrameworkDirectory};
+ {RawFileName};
+
+
+
+
+ C#
+ VB
+ F#
+ C++
+
+
+
+
+
+
+
+
+ C#
+ $(MSBuildToolsPath)\Microsoft.CSharp.targets
+
+
+
+
+
+ VB
+ $(MSBuildToolsPath)\Microsoft.VisualBasic.targets
+
+
+
+
+
+
+
+
+
+
+
+
+ true
+ $(NoWarn);1701;1702;1705;1591
+
+
+
+ true
+ DEBUG;TRACE
+
+
+
+ TRACE
+ true
+
+
+
+
+
+
+ Empty
+ Binary
+ On
+ On
+ On
+ Embed
+ true
+
+
+
+ true
+ true
+ true
+
+
+
+ true
+ true
+
+
+
+
+
+
+
+ false
+
+
+
+
diff --git a/build/Targets/RepoToolset/Publish.proj b/build/Targets/RepoToolset/Publish.proj
new file mode 100644
index 0000000000000..17efc76d201dd
--- /dev/null
+++ b/build/Targets/RepoToolset/Publish.proj
@@ -0,0 +1,145 @@
+
+
+
+
+
+
+
+ false
+ true
+
+ false
+ true
+
+ false
+ true
+
+
+
+
+ $(ArtifactsPackagesDir)PerBuildPreRelease
+ $(ArtifactsPackagesDir)Release
+ $(ArtifactsPackagesDir)PreRelease
+
+
+
+
+
+
+
+ $(ArtifactsTmpDir)SymbolPackages\
+
+
+
+
+
+
+
+
+ $(SymbolPackagesDir)%(Filename).symbols.nupkg
+
+
+
+ %(PackagesToPublish.Identity)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 3650
+ false
+
+
+
+ true
+ DryRunPTA
+ DryRunPTA
+
+
+
+
+
+
+
+
+ false
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/RepoLayout.props b/build/Targets/RepoToolset/RepoLayout.props
index e032f7ac95f38..886def152d5e0 100644
--- a/build/Targets/RepoToolset/RepoLayout.props
+++ b/build/Targets/RepoToolset/RepoLayout.props
@@ -24,14 +24,22 @@
TODO: values differ from RepoToolset
-->
- <_EngDir>$(RepoRoot)build\Targets\
+ $(RepoRoot)build\Targets\
- $(_EngDir)Packages.props
- $(_EngDir)FixedPackages.props
+ $(RepositoryEngineeringDir)Packages.props
+ $(RepositoryEngineeringDir)FixedPackages.props
$(RepoRoot)Binaries\
$(ArtifactsDir)toolset\
$(ArtifactsDir)$(Configuration)\
$(ArtifactsConfigurationDir)SymStore\
+ $(ArtifactsConfigurationDir)tmp\
+ $(ArtifactsConfigurationDir)Logs\
+ $(ArtifactsConfigurationDir)NuGet\
+ $(ArtifactsPackagesDir)Shipping\
+ $(ArtifactsPackagesDir)NonShipping\
+ $(ArtifactsDir)VSSetup\$(Configuration)\
+ $(VisualStudioSetupOutputPath)Insertion\
+ $(ArtifactsDir)VSSetup.obj\$(Configuration)\
diff --git a/build/Targets/RepoToolset/RepositoryInfo.targets b/build/Targets/RepoToolset/RepositoryInfo.targets
index 438e861edac6a..52b837fa52d35 100644
--- a/build/Targets/RepoToolset/RepositoryInfo.targets
+++ b/build/Targets/RepoToolset/RepositoryInfo.targets
@@ -5,12 +5,33 @@
$(MSBuildAllProjects);$(MSBuildThisFileFullPath)
-
- GitHub
-
-
+
-
+
+
+
+
+
+
+ <_Pattern>https://dotnet.visualstudio.com/internal/_git/([^/-]+)-(.+)
+ <_Replacement>https://github.com/$1/$2
+
+
+
+ $([System.Text.RegularExpressions.Regex]::Replace($(ScmRepositoryUrl), $(_Pattern), $(_Replacement)))
+
+
+
+
+ $([System.Text.RegularExpressions.Regex]::Replace(%(SourceRoot.ScmRepositoryUrl), $(_Pattern), $(_Replacement)))
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/Sign.proj b/build/Targets/RepoToolset/Sign.proj
new file mode 100644
index 0000000000000..42683eeb48d1b
--- /dev/null
+++ b/build/Targets/RepoToolset/Sign.proj
@@ -0,0 +1,74 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_DryRun>true
+ <_DryRun Condition="'$(OfficialBuild)' == 'true'">false
+
+ <_TestSign>false
+ <_TestSign Condition="'$(DotNetSignType)' == 'test'">true
+
+ <_DesktopMSBuildRequired>false
+ <_DesktopMSBuildRequired Condition="'$(_DryRun)' != 'true' and '$(MSBuildRuntimeType)' == 'Core'">true
+
+
+
+
+
+
+
+
+ <_DesktopMSBuildPath Condition="$(_DesktopMSBuildRequired)">$(_VSInstallDir)\MSBuild\15.0\Bin\msbuild.exe
+
+
+
+
+
+
+
diff --git a/build/Targets/RepoToolset/StrongName.props b/build/Targets/RepoToolset/StrongName.props
new file mode 100644
index 0000000000000..f36f8578e8246
--- /dev/null
+++ b/build/Targets/RepoToolset/StrongName.props
@@ -0,0 +1,13 @@
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+ 0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9
+ 002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293
+ 0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/StrongName.targets b/build/Targets/RepoToolset/StrongName.targets
new file mode 100644
index 0000000000000..84e4af4b7fa45
--- /dev/null
+++ b/build/Targets/RepoToolset/StrongName.targets
@@ -0,0 +1,50 @@
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+ false
+ true
+
+
+
+
+
+
+ $(MSBuildThisFileDirectory)MSFT.snk
+ $(MicrosoftPublicKey)
+ b03f5f7f11d50a3a
+
+
+
+
+ $(MSBuildThisFileDirectory)35MSSharedLib1024.snk
+ $(MicrosoftSharedPublicKey)
+ 31BF3856AD364E35
+
+
+
+
+ $(MSBuildThisFileDirectory)AspNet.snk
+ $(MicrosoftAspNetPublicKey)
+ adb9793829ddae60
+ false
+
+
+
+
+
+
+
+ $(PrepareForBuildDependsOn);VerifyBuildFlags
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/SymStore.targets b/build/Targets/RepoToolset/SymStore.targets
index ab4da61fa7f25..c6a2f1b77bc66 100644
--- a/build/Targets/RepoToolset/SymStore.targets
+++ b/build/Targets/RepoToolset/SymStore.targets
@@ -21,7 +21,7 @@ Update this file only if the change to RepoToolset gets approved and merged.
-
+
@@ -42,7 +42,7 @@ Update this file only if the change to RepoToolset gets approved and merged.
<_SymStoreOutputDir>$(ArtifactsSymStoreDirectory)$(MSBuildProjectName)\$(TargetFramework)\
<_SymStorePdbPath>$(_SymStoreOutputDir)$(TargetName).pdb
<_SymStoreAssemblyPath>$(_SymStoreOutputDir)$(TargetName)$(TargetExt)
-
+
true
@@ -51,6 +51,9 @@ Update this file only if the change to RepoToolset gets approved and merged.
Convert Portable and Embedded PDBs.
We publish converted PDBs to Symbol Store so that WinDBG can find them when debugging crash dumps.
Convert source link to srcsvr so that both WinDBG and VS can open the source files.
+
+ We add SRC_INDEX=public srcsvr variable in order to preserve the source server stream when
+ it's published to the public symbol server (msdl.microsoft.com).
-->
<_PdbConverterPath>$(NuGetPackageRoot)microsoft.diasymreader.pdb2pdb\$(MicrosoftDiaSymReaderPdb2PdbVersion)\tools\Pdb2Pdb.exe
- <_PdbConverterCommandLineArgs>"$(TargetPath)" /out "$(_SymStorePdbPath)" /verbose
+ <_PdbConverterCommandLineArgs>"$(TargetPath)" /out "$(_SymStorePdbPath)" /verbose /srcsvrvar SRC_INDEX=public
diff --git a/build/Targets/RepoToolset/Version.props b/build/Targets/RepoToolset/Version.props
new file mode 100644
index 0000000000000..68d5f06cf5422
--- /dev/null
+++ b/build/Targets/RepoToolset/Version.props
@@ -0,0 +1,92 @@
+
+
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+
+
+ <_BuildNumber>$(OfficialBuildId)
+ <_BuildNumber Condition="'$(OfficialBuildId)' == ''">$([System.DateTime]::Now.ToString(yyyyMMdd)).1
+
+
+ <_BuildNumberFiveDigitDateStamp>$([MSBuild]::Subtract($(_BuildNumber.Split($([System.Convert]::ToString(`.`).ToCharArray())).GetValue($([System.Convert]::ToInt32(0)))), 20100000))
+ <_BuildNumberFiveDigitDateStampYearsToOffset>$([System.Math]::Max($([System.Convert]::ToInt32($([MSBuild]::Subtract($([MSBuild]::Divide($(_BuildNumberFiveDigitDateStamp), 10000)), 6)))), 0))
+
+ $([MSBuild]::Subtract($([System.Convert]::ToInt32($(_BuildNumberFiveDigitDateStamp))), $([MSBuild]::Multiply($(_BuildNumberFiveDigitDateStampYearsToOffset), 8800))))
+ $(_BuildNumber.Split($([System.Convert]::ToString(`.`).ToCharArray())).GetValue($([System.Convert]::ToInt32(1))))
+ $(VersionSuffixBuildOfTheDay.PadLeft($([System.Convert]::ToInt32(2)), $([System.Convert]::ToChar(`0`))))
+
+ <_BuildNumberSuffix Condition="'$(SemanticVersioningV1)' != 'true'">.$(VersionSuffixDateStamp).$(VersionSuffixBuildOfTheDay)
+ <_BuildNumberSuffix Condition="'$(SemanticVersioningV1)' == 'true'">-$(VersionSuffixDateStamp)-$(VersionSuffixBuildOfTheDayPadded)
+
+
+
+
+
+
+
+ <_BuildNumberSuffix/>
+
+
+ false
+
+
+
+
+
+ <_PreReleaseLabel>$(PreReleaseVersionLabel)
+ <_PreReleaseLabel Condition="'$(ContinuousIntegrationBuild)' == 'true' and '$(OfficialBuild)' != 'true'">ci
+ <_PreReleaseLabel Condition="'$(ContinuousIntegrationBuild)' != 'true'">dev
+
+
+
+ $(_PreReleaseLabel)
+ $(_PreReleaseLabel)$(_BuildNumberSuffix)
+
+
+ $(NoWarn);NU5105
+
+
+
diff --git a/build/Targets/RepoToolset/Version.targets b/build/Targets/RepoToolset/Version.targets
new file mode 100644
index 0000000000000..2427ce9a9cb78
--- /dev/null
+++ b/build/Targets/RepoToolset/Version.targets
@@ -0,0 +1,57 @@
+
+
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+
+
+ $(VersionPrefix).$(VersionSuffixDateStamp)
+
+
+
+
+ 42.42.42.42424
+
+
+ 42.42.42.42
+
+
+
+
+
+
+ <_ShortSha>$(SourceRevisionId)
+ <_ShortSha Condition="$(SourceRevisionId.Length) > 7">$(SourceRevisionId.Substring(0, 8))
+
+ $(Version)+$(_ShortSha)
+ $(Version)-$(_ShortSha)
+
+
+
+
diff --git a/build/Targets/RepoToolset/VisualStudio.DesignTimeBuild.targets b/build/Targets/RepoToolset/VisualStudio.DesignTimeBuild.targets
new file mode 100644
index 0000000000000..9977977bea263
--- /dev/null
+++ b/build/Targets/RepoToolset/VisualStudio.DesignTimeBuild.targets
@@ -0,0 +1,18 @@
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/VisualStudio.ImportSdk.targets b/build/Targets/RepoToolset/VisualStudio.ImportSdk.targets
new file mode 100644
index 0000000000000..0d42f352ebc22
--- /dev/null
+++ b/build/Targets/RepoToolset/VisualStudio.ImportSdk.targets
@@ -0,0 +1,11 @@
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/VisualStudio.InsertionManifests.targets b/build/Targets/RepoToolset/VisualStudio.InsertionManifests.targets
new file mode 100644
index 0000000000000..46e4b0ad70842
--- /dev/null
+++ b/build/Targets/RepoToolset/VisualStudio.InsertionManifests.targets
@@ -0,0 +1,39 @@
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+ <_StubFiles Include="$(VisualStudioSetupIntermediateOutputPath)**\*.stub"/>
+ <_StubDirs Include="@(_StubFiles->'%(RecursiveDir)')"/>
+
+
+
+
+
+ <_ComponentDir>%(_StubDirs.Identity)
+ <_ComponentName>$(_ComponentDir.TrimEnd('\'))
+
+
+
+ <_Args Include="OfficialBuild=$(OfficialBuild)" />
+ <_Args Include="ComponentName=$(_ComponentName)"/>
+ <_Args Include="SetupOutputPath=$(VisualStudioSetupInsertionPath)"/>
+ <_Args Include="ComponentIntermediateOutputPath=$(VisualStudioSetupIntermediateOutputPath)$(_ComponentName)\"/>
+ <_Args Include="SwixBuildPath=$(NuGetPackageRoot)microbuild.plugins.swixbuild\$(MicroBuildPluginsSwixBuildVersion)\"/>
+ <_Args Include="ManifestBuildVersion=$(VsixVersion)" />
+
+
+
+
+
+
+
+
diff --git a/build/Targets/RepoToolset/VisualStudio.SetupPackage.swixproj b/build/Targets/RepoToolset/VisualStudio.SetupPackage.swixproj
new file mode 100644
index 0000000000000..bf6553cf87673
--- /dev/null
+++ b/build/Targets/RepoToolset/VisualStudio.SetupPackage.swixproj
@@ -0,0 +1,36 @@
+
+
+
+
+
+ neutral
+ false
+ vsix
+ true
+ $(SwrPackageName)
+
+
+
+
+
+ <_SwrProperties Include="$([MSBuild]::Unescape($(SwrProperties)))" />
+
+
+
+ $(PackagePreprocessorDefinitions);@(_SwrProperties)
+ $(IntermediateOutputPath)
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/VisualStudio.SetupPackage.vsmanproj b/build/Targets/RepoToolset/VisualStudio.SetupPackage.vsmanproj
new file mode 100644
index 0000000000000..ac44819cd0542
--- /dev/null
+++ b/build/Targets/RepoToolset/VisualStudio.SetupPackage.vsmanproj
@@ -0,0 +1,37 @@
+
+
+
+
+
+ false
+ false
+ false
+
+
+
+
+
+ false
+ true
+
+ true
+ true
+ $(ComponentName)
+ $(SetupOutputPath)
+ $(ComponentIntermediateOutputPath)
+
+
+
+ <_PackageStubFiles Include="$(ComponentIntermediateOutputPath)*.stub"/>
+
+
+
+
+
diff --git a/build/Targets/RepoToolset/VisualStudio.props b/build/Targets/RepoToolset/VisualStudio.props
new file mode 100644
index 0000000000000..5be0fb66f5aba
--- /dev/null
+++ b/build/Targets/RepoToolset/VisualStudio.props
@@ -0,0 +1,32 @@
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+ $(VersionPrefix).$(VersionSuffixDateStamp)$(VersionSuffixBuildOfTheDayPadded)
+ 42.42.42.4242424
+
+
+
+
+ $(MSBuildProjectDirectory)\source.extension.vsixmanifest
+ false
+ true
+
+
+
+
+
+
+
+ false
+
+ Program
+ $(DevEnvDir)devenv.exe
+ /rootsuffix $(VSSDKTargetPlatformRegRootSuffix) /log
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/VisualStudio.targets b/build/Targets/RepoToolset/VisualStudio.targets
new file mode 100644
index 0000000000000..fe7989453e1a3
--- /dev/null
+++ b/build/Targets/RepoToolset/VisualStudio.targets
@@ -0,0 +1,267 @@
+
+
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+ <_TargetVsixContainerDir>$(VisualStudioSetupOutputPath)
+
+ $(TargetName).vsix
+ $(_TargetVsixContainerDir)$(TargetVsixContainerName)
+
+
+
+ <_ComponentIntermediateDir>$(VisualStudioSetupIntermediateOutputPath)$(VisualStudioInsertionComponent)\
+
+ true
+
+ true
+ All
+ 3
+
+
+
+
+ true
+ All
+ 3
+
+
+
+
+
+
+ <_VsxXmlNamespace><Namespace Prefix='vsx' Uri='http://schemas.microsoft.com/developer/vsx-schema/2011'/>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_PackageStubFile>$(_ComponentIntermediateDir)$(_VsixPackageId).stub
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_JsonFileName>$(_VsixPackageId).json
+
+
+
+ <_FinalizeInsertionVsixFilesInputs Include="$(VisualStudioSetupOutputPath)$(TargetVsixContainerName)" />
+ <_FinalizeInsertionVsixFilesInputs Include="$(VisualStudioSetupOutputPath)$(_JsonFileName)" />
+
+ <_FinalizeInsertionVsixFilesOutputs Include="$(VisualStudioSetupInsertionPath)$(TargetVsixContainerName)" />
+ <_FinalizeInsertionVsixFilesOutputs Include="$(VisualStudioSetupInsertionPath)$(_JsonFileName)" />
+
+
+
+
+
+
+
+
+
+
+ <_ModifyVsixManifestToolExe>$(NuGetPackageRoot)roslyntools.modifyvsixmanifest\$(RoslynToolsModifyVsixManifestVersion)\tools\ModifyVsixManifest.exe
+ <_ModifyVsixManifestArgs>--remove=//x:PackageManifest/x:Installation/@Experimental --add-attribute=//x:PackageManifest/x:Installation;SystemComponent;true
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_SwrProperties>@(SwrProperty)
+ <_SwrFiles>@(SwrFile->'%(FullPath)')
+
+
+ <_SwixArgs Include="SwrProperties=$([MSBuild]::Escape($(_SwrProperties)))"/>
+ <_SwixArgs Include="SwrFiles=$([MSBuild]::Escape($(_SwrFiles)))"/>
+ <_SwixArgs Include="SwrPackageName=$(_VsixPackageId)"/>
+ <_SwixArgs Include="IntermediateOutputPath=$(IntermediateOutputPath)"/>
+ <_SwixArgs Include="SwixBuildPath=$(NuGetPackageRoot)microbuild.plugins.swixbuild\$(MicroBuildPluginsSwixBuildVersion)\"/>
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_VsixPackageId>$([System.IO.Path]::GetFileNameWithoutExtension($(TargetVsixContainerName)))
+ <_PackageStubFile>$(_ComponentIntermediateDir)$(_VsixPackageId).stub
+ <_JsonFileName>$(_VsixPackageId).json
+
+
+
+ <_SwixBuildOutputs Include="$(VisualStudioSetupInsertionPath)$(TargetVsixContainerName)" />
+ <_SwixBuildOutputs Include="$(VisualStudioSetupInsertionPath)$(_JsonFileName)" />
+
+
+
+
+
+
+ <_GeneratedCTOFilesWithCulture Include="@(_GeneratedCTOFilesWithNoCulture)">
+ en
+ true
+
+ <_GeneratedCTOFilesWithNoCulture Remove="@(_GeneratedCTOFilesWithNoCulture)" />
+ <_ResourcesToMergeWithCTOWithCultureMetadata Condition="'%(WithCulture)' != 'true'">
+ en
+ true
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ %(IntermediateZipItem.Filename)\%(IntermediateZipItem.Language)\%(IntermediateZipItem.OutputSubPath)\%(IntermediateZipItem.Culture)
+
+
+ %(IntermediateZipProject.Filename)\%(IntermediateZipProject.Language)\%(IntermediateZipProject.OutputSubPath)\%(IntermediateZipProject.Culture)
+
+
+
+
+ $(GetVsixSourceItemsDependsOn);_GetVsixTemplateItems
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/build/Targets/RepoToolset/Workarounds.targets b/build/Targets/RepoToolset/Workarounds.targets
index 2f3d27f5627fc..a20909c8fbc00 100644
--- a/build/Targets/RepoToolset/Workarounds.targets
+++ b/build/Targets/RepoToolset/Workarounds.targets
@@ -18,10 +18,10 @@
-
+
false
@@ -58,4 +58,75 @@
$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb
+
+
+
+
+
+ $(RepositoryUrl)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @(NuspecProperty, ';')
+
+
+
+
+
+
+
+ $(PrivateRepositoryUrl)
+ $(SourceRevisionId)
+
+
+
+
+
+ *$(MSBuildProjectName)*
+
+
+
+
+ $(NuspecPackageId)
+
+
\ No newline at end of file
diff --git a/build/Targets/Roslyn.Toolsets.Xunit.targets b/build/Targets/Roslyn.Toolsets.Xunit.targets
index 7e74dd750f43c..5d58888befc44 100644
--- a/build/Targets/Roslyn.Toolsets.Xunit.targets
+++ b/build/Targets/Roslyn.Toolsets.Xunit.targets
@@ -6,6 +6,31 @@
$(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+
+
+
+
+
+
+
+
$(NuGetPackageRoot)\xunit.runner.console\$(xunitrunnerconsoleVersion)\tools\net452\xunit.console.x86.exe
diff --git a/build/Targets/Settings.props b/build/Targets/Settings.props
index 4fcc6aadef6a6..b428b2b84272c 100644
--- a/build/Targets/Settings.props
+++ b/build/Targets/Settings.props
@@ -8,60 +8,43 @@
https://github.com/dotnet/roslyn
+ $(RepositoryUrl)/blob/master/License.txt
https://raw.githubusercontent.com/dotnet/roslyn
+ https://github.com/dotnet/roslyn
+ Roslyn CodeAnalysis Compiler CSharp VB VisualBasic Parser Scanner Lexer Emit CodeGeneration Metadata IL Compilation Scripting Syntax Semantics
+ RoslynDev
-
+
+
+
-
- Microsoft Corporation
- © Microsoft Corporation. All rights reserved.
- Microsoft
-
- false
- true
- false
- true
- true
-
- $(RepoRoot)nuget.exe
true
$(RepoRoot)build\ToolsetPackages\
- RoslynTools.Microsoft.VSIXExpInstaller
- 0.2.1-beta
- $(MicrosoftNetRoslynDiagnosticsVersion)
-
- False
- $(NuGetPackageRoot)/microsoft.net.roslyndiagnostics/$(RoslynDiagnosticsNugetPackageVersion)/build/Microsoft.Net.RoslynDiagnostics.props
+
net46;netcoreapp2.0
win;win-x64;linux-x64;osx-x64
win
win-x86
true
- true
strict, IOperation
true
- true
true
true
-
- false
true
+ $(MSBuildThisFileDirectory)..\..\src\NuGet\ThirdPartyNotices.rtf
$(NuGetPackageRoot)\roslyntools.referenceassemblies\$(RoslynToolsReferenceAssembliesVersion)\tools\framework
15.0
$(VisualStudioVersion.Substring($([System.Convert]::ToInt32(0)), $(VisualStudioVersion.IndexOf('.'))))
$(VisualStudioReferenceMajorVersion).0.0.0
- Dev$(VisualStudioReferenceMajorVersion)
$(VisualStudioVersion)
false
- Core
-
-
-
- {TargetFrameworkDirectory};
- {RawFileName};
-
-
-
- false
-
- PackageReference
-
-
- $(LiveUnitTestingOriginalBaseIntermediateOutputPath)project.assets.json
-
-
- CurrentRuntime
-
-
- full
- portable
- embedded
-
- SHA256
-
false
- true
-
@@ -136,18 +71,32 @@
$(MSBuildThisFileDirectory)\BeforeCommonTargets.targets
$(MSBuildThisFileDirectory)\AfterCommonTargets.targets
+
+
+
+ 0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7
+ 002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293
+ 002400000c800000940000000602000000240000525341310004000001000100e1290d741888d13312c0cd1f72bb843236573c80158a286f11bb98de5ee8acc3142c9c97b472684e521ae45125d7414558f2e70ac56504f3e8fe80830da2cdb1cda8504e8d196150d05a214609234694ec0ebf4b37fc7537e09d877c3e65000f7467fa3adb6e62c82b10ada1af4a83651556c7d949959817fed97480839dd39b
+ 0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb
+ 0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9
+ $(VisualStudioKey)
+ $(VisualStudioKey)
+ $(VisualStudioKey)
+ $(VisualStudioKey)
+
<_PackageName Condition="'$(MSBuildRuntimeType)' != 'Core'">Microsoft.Net.Compilers
<_PackageName Condition="'$(MSBuildRuntimeType)' == 'Core'">Microsoft.NETCore.Compilers
- <_PackageVersion Condition="'$(MSBuildRuntimeType)' != 'Core' AND '$(BootstrapBuildPath)' == ''">$(MicrosoftNetCompilersVersion)
- <_PackageVersion Condition="'$(MSBuildRuntimeType)' == 'Core' AND '$(BootstrapBuildPath)' == ''">$(MicrosoftNETCoreCompilersVersion)
- <_PackageVersion Condition="'$(BootstrapBuildPath)' != ''">42.42.42.42
- <_PackageRoot>$(NuGetPackageRoot)
- <_PackageRoot Condition="'$(BootstrapBuildPath)' != ''">$(BootstrapBuildPath)
- $(_PackageRoot)\$(_PackageName.ToLower())\$(_PackageVersion)
- $(RoslynToolsetDirectory)\build\$(_PackageName).props
+ <_PackageVersion Condition="'$(MSBuildRuntimeType)' != 'Core'">$(MicrosoftNetCompilersVersion)
+ <_PackageVersion Condition="'$(MSBuildRuntimeType)' == 'Core'">$(MicrosoftNETCoreCompilersVersion)
+
+ $(NuGetPackageRoot)$(_PackageName.ToLower())\$(_PackageVersion)\
+ $(BootstrapBuildPath)
+ $(RoslynToolsetDirectory)\
+
+ $(RoslynToolsetDirectory)build\$(_PackageName).props
@@ -157,8 +106,7 @@
- false
- $(MicrosoftVSSDKBuildToolsVersion)
+ false
@@ -170,70 +118,32 @@
-
-
-
-
-
+
+
+
+
+
+
-
-
-
-
-
- VB
- $(MSBuildToolsPath)\Microsoft.VisualBasic.targets
-
-
-
-
- C#
- $(MSBuildToolsPath)\Microsoft.CSharp.targets
-
-
-
-
-
-
-
+ Language specifc settings
+ -->
-
+
- VB
15.5
- Empty
- Binary
- On
- On
- On
- Embed
true
- VisualBasic
$(NoWarn);40057
@@ -246,24 +156,14 @@
-
- true
- true
- true
-
-
- true
- true
-
$(InitialDefineConstants)
-
+
- CSharp
7.3
4
prompt
@@ -279,35 +179,10 @@
-->
$(NoWarn);1573;1591;1701
false
- CSharp
-
-
- true
- DEBUG;TRACE
-
-
- TRACE
- true
$(DefineConstants);$(InitialDefineConstants)
-
-
-
-
- C++
-
- $(IntermediateOutputPath)
-
-
- v$(VisualStudioReferenceMajorVersion)0
-
-
-
-
- $(RoslynDebugType)
-
diff --git a/build/Targets/Signing.props b/build/Targets/Signing.props
new file mode 100644
index 0000000000000..230a5ceec30f2
--- /dev/null
+++ b/build/Targets/Signing.props
@@ -0,0 +1,35 @@
+
+
+
+
+
+ $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/Targets/Tools.props b/build/Targets/Tools.props
index ab92e40ff2aac..3060a30a11966 100644
--- a/build/Targets/Tools.props
+++ b/build/Targets/Tools.props
@@ -20,7 +20,7 @@
- Update links and version numbers in docs/contributing/Building%2C%20Debugging%2C%20and%20Testing%20on%20Windows.md
- Email the team to ask them to upgrade to the new SDK
-->
- 2.1.300-rtm-008866
+ 2.1.401
5.8.0.88
15.7
diff --git a/build/Targets/Versions.props b/build/Targets/Versions.props
deleted file mode 100644
index c1e4dfebc605a..0000000000000
--- a/build/Targets/Versions.props
+++ /dev/null
@@ -1,95 +0,0 @@
-
-
-
-
-
- $(MSBuildAllProjects);$(MSBuildThisFileFullPath)
-
-
-
-
-
-
-
- 2.10.0
-
-
- 2.10.0
-
-
- dev
-
- ranges-v2
-
-
- $(RoslynFileVersionBase)-$(RoslynNuGetMoniker)
-
-
- $(BUILD_BUILDNUMBER)
- A build number must be specified for a signed build.
-
-
- 65535
- 01
-
-
-
-
- BuildNumber should have two parts (in the form of 'x.y')
-
-
- $([MSBuild]::Subtract($(BuildNumber.Split($([System.Convert]::ToString(`.`).ToCharArray())).GetValue($([System.Convert]::ToInt32(0)))), 20100000))
- <_BuildNumberFiveDigitDateStampYearsToOffset>$([System.Math]::Max($([System.Convert]::ToInt32($([MSBuild]::Subtract($([MSBuild]::Divide($(BuildNumberFiveDigitDateStamp), 10000)), 6)))), 0))
- $([MSBuild]::Subtract($([System.Convert]::ToInt32($(BuildNumberFiveDigitDateStamp))), $([MSBuild]::Multiply($(_BuildNumberFiveDigitDateStampYearsToOffset), 8800))))
- $(BuildNumber.Split($([System.Convert]::ToString(`.`).ToCharArray())).GetValue($([System.Convert]::ToInt32(1))).PadLeft($([System.Convert]::ToInt32(2)), $([System.Convert]::ToChar(`0`))))
-
-
-
-
- $(RoslynFileVersionBase)
- $(NuGetPreReleaseVersion)-$(BuildNumberFiveDigitDateStamp)-$(BuildNumberBuildOfTheDayPadded)
-
-
-
-
-
- $(RoslynAssemblyVersionBase).0
- $(RoslynFileVersionBase).$(BuildNumberFiveDigitDateStamp)
- $(RoslynFileVersionBase).$(BuildNumberFiveDigitDateStamp)$(BuildNumberBuildOfTheDayPadded)
-
-
-
-
-
-
- 42.42.42.42
- 42.42.42.42424
- 42.42.42.42424
-
-
-
-
-
-
- false
- $(NuGetPerBuildPreReleaseVersion)
-
-
diff --git a/build/Targets/VisualStudio.targets b/build/Targets/VisualStudio.targets
index c93f29113ad4c..078a89aa78ded 100644
--- a/build/Targets/VisualStudio.targets
+++ b/build/Targets/VisualStudio.targets
@@ -7,8 +7,6 @@
- true
-
$(GetVsixSourceItemsDependsOn);IncludeVsixLocalOnlyItems
$(GetVsixSourceItemsDependsOn);IncludeNuGetResolvedAssets
@@ -24,15 +22,6 @@
false
-
-
-
-
-
-
-
-
-
@@ -90,55 +79,32 @@
-
-
+
+
-
+
+
+ false
+
+
+
+
+ false
+
+
+
+
+ false
+
+
+
true
-
-
-
-
- <_GeneratedCTOFilesWithCulture Include="@(_GeneratedCTOFilesWithNoCulture)">
- en
- true
-
- <_GeneratedCTOFilesWithNoCulture Remove="@(_GeneratedCTOFilesWithNoCulture)" />
- <_ResourcesToMergeWithCTOWithCultureMetadata Condition="'%(WithCulture)' != 'true'">
- en
- true
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/build/Targets/Vsdconfig.targets b/build/Targets/Vsdconfig.targets
index 8175e2ade4cfc..10bb8b993e1c6 100644
--- a/build/Targets/Vsdconfig.targets
+++ b/build/Targets/Vsdconfig.targets
@@ -13,7 +13,7 @@
Outputs="$(OutDir)\$(AssemblyName).vsdconfig"
Condition="'$(BuildingProject)' == 'true' AND '@(VsdConfigXml)' != '' AND '$(IsWpfTempProject)' != 'true'">
- <_VsdConfigTool>$(NuGetPackageRoot)\Microsoft.VSSDK.BuildTools\$(VisualStudioBuildToolsVersion)\tools\VSSDK\bin\vsdconfigtool.exe
+ <_VsdConfigTool>$(NuGetPackageRoot)\Microsoft.VSSDK.BuildTools\$(MicrosoftVSSDKBuildToolsVersion)\tools\VSSDK\bin\vsdconfigtool.exe
diff --git a/build/Toolset/Program.cs b/build/Toolset/Program.cs
deleted file mode 100644
index 3859fe1967c75..0000000000000
--- a/build/Toolset/Program.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System;
-
-namespace DoNotUse
-{
- public class Program
- {
- private static void Main(string[] args)
- {
- throw new Exception("Do not use");
- }
- }
-}
diff --git a/build/Toolset/Toolset.csproj b/build/Toolset/Toolset.csproj
deleted file mode 100644
index 896c8f1ae6a86..0000000000000
--- a/build/Toolset/Toolset.csproj
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-
-
- AnyCPU
- AnyCPU
- Exe
- Toolset_DoNotUse
- net46
- $(RoslynCrossPlatformRuntimeIdentifiers)
- true
- true
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/build/Toolset/Toolset_DoNetUse.xml b/build/Toolset/Toolset_DoNetUse.xml
deleted file mode 100644
index 30da0a393e944..0000000000000
--- a/build/Toolset/Toolset_DoNetUse.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-
- Toolset_DoNetUse
-
-
-
-
diff --git a/build/ToolsetPackages/RoslynToolset.csproj b/build/ToolsetPackages/RoslynToolset.csproj
index ab63e00e2b147..a5ee6d650c826 100644
--- a/build/ToolsetPackages/RoslynToolset.csproj
+++ b/build/ToolsetPackages/RoslynToolset.csproj
@@ -6,16 +6,18 @@
-
-
+
+
+
+
@@ -28,14 +30,13 @@
-
+
+
-
-
diff --git a/build/config/PublishData.json b/build/config/PublishData.json
index c4574c5a49ce7..a631b086e0db0 100644
--- a/build/config/PublishData.json
+++ b/build/config/PublishData.json
@@ -1,60 +1,32 @@
{
"branches": {
"master-vs-deps": {
- "nugetKind": "PerBuildPreRelease",
- "version": "2.8.*",
- "nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
- "vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
- "channels": [ "dev15.8" ]
- },
- "dev15.6-preview2-vs-deps": {
- "nugetKind": "PerBuildPreRelease",
- "version": "2.7.*",
- "nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
- "vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
- "channels": [ "dev15.6p2" ]
- },
- "dev15.6.x-vs-deps": {
- "nugetKind": "PerBuildPreRelease",
- "version": "2.7.*",
+ "nugetKind": ["Shipping", "NonShipping"],
+ "version": "2.11.*",
"nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
"vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
- "channels": [ "dev15.6p4", "dev15.6" ]
+ "channels": [ "dev16" ]
},
"dev15.7.x-vs-deps": {
"nugetKind": "PerBuildPreRelease",
"version": "2.8.*",
"nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
"vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
- "channels": [ "dev15.7p2", "dev15.7" ]
+ "channels": [ "dev15.7" ]
},
- "dev15.7-preview1-vs-deps": {
- "nugetKind": "PerBuildPreRelease",
- "version": "2.8.*",
- "nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
- "vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
- "channels": [ "dev15.7p1"]
- },
- "dev15.8-preview1-vs-deps": {
+ "dev15.8.x-vs-deps": {
"nugetKind": "PerBuildPreRelease",
"version": "2.9.*",
"nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
"vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
- "channels": [ "dev15.8p1"]
+ "channels": [ "dev15.8", "dev15.8p5"]
},
- "dev15.8-preview3-vs-deps": {
+ "dev15.9.x-vs-deps": {
"nugetKind": "PerBuildPreRelease",
- "version": "2.9.*",
- "nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
- "vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
- "channels": [ "dev15.8p3"]
- },
- "dev15.5.x": {
- "nugetKind": "PerBuildPreRelease",
- "version": "2.6.*",
+ "version": "2.10.*",
"nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
"vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
- "channels": [ "dev15.5", "dev15.5p3" ]
+ "channels": [ "dev15.9p1"]
},
"features/NullableReferenceTypes": {
"nugetKind": "PerBuildPreRelease",
diff --git a/build/config/SignToolData.json b/build/config/SignToolData.json
deleted file mode 100644
index ebc84ba9ce99e..0000000000000
--- a/build/config/SignToolData.json
+++ /dev/null
@@ -1,276 +0,0 @@
-{
- "sign": [
- {
- "certificate": "MicrosoftSHA2",
- "strongName": "MsSharedLib72",
- "values": [
- "Dlls\\BasicCodeAnalysis\\Microsoft.CodeAnalysis.VisualBasic.dll",
- "Dlls\\BasicCodeAnalysis\\*\\Microsoft.CodeAnalysis.VisualBasic.resources.dll",
- "Dlls\\BasicCodeStyle\\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.dll",
- "Dlls\\BasicCodeStyle\\*\\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.resources.dll",
- "Dlls\\BasicCodeStyleFixes\\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes.dll",
- "Dlls\\BasicCodeStyleFixes\\*\\Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes.resources.dll",
- "Dlls\\BasicEditorFeatures\\Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.dll",
- "Dlls\\BasicEditorFeatures\\*\\Microsoft.CodeAnalysis.VisualBasic.EditorFeatures.resources.dll",
- "Dlls\\BasicFeatures\\Microsoft.CodeAnalysis.VisualBasic.Features.dll",
- "Dlls\\BasicFeatures\\*\\Microsoft.CodeAnalysis.VisualBasic.Features.resources.dll",
- "Dlls\\BasicInteractiveEditorFeatures\\Microsoft.CodeAnalysis.VisualBasic.InteractiveEditorFeatures.dll",
- "Dlls\\BasicInteractiveEditorFeatures\\*\\Microsoft.CodeAnalysis.VisualBasic.InteractiveEditorFeatures.resources.dll",
- "Dlls\\BasicScripting\\Microsoft.CodeAnalysis.VisualBasic.Scripting.dll",
- "Dlls\\BasicScripting\\*\\Microsoft.CodeAnalysis.VisualBasic.Scripting.resources.dll",
- "Dlls\\BasicVisualStudioRepl\\Microsoft.VisualStudio.VisualBasic.Repl.dll",
- "Dlls\\BasicVisualStudioRepl\\*\\Microsoft.VisualStudio.VisualBasic.Repl.resources.dll",
- "Dlls\\BasicVisualStudio\\Microsoft.VisualStudio.LanguageServices.VisualBasic.dll",
- "Dlls\\BasicVisualStudio\\*\\Microsoft.VisualStudio.LanguageServices.VisualBasic.resources.dll",
- "Dlls\\BasicWorkspace\\Microsoft.CodeAnalysis.VisualBasic.Workspaces.dll",
- "Dlls\\BasicWorkspace\\*\\Microsoft.CodeAnalysis.VisualBasic.Workspaces.resources.dll",
- "Dlls\\CSharpCodeAnalysis\\Microsoft.CodeAnalysis.CSharp.dll",
- "Dlls\\CSharpCodeAnalysis\\*\\Microsoft.CodeAnalysis.CSharp.resources.dll",
- "Dlls\\CSharpCodeStyle\\Microsoft.CodeAnalysis.CSharp.CodeStyle.dll",
- "Dlls\\CSharpCodeStyle\\*\\Microsoft.CodeAnalysis.CSharp.CodeStyle.resources.dll",
- "Dlls\\CSharpCodeStyleFixes\\Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes.dll",
- "Dlls\\CSharpCodeStyleFixes\\*\\Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes.resources.dll",
- "Dlls\\CSharpEditorFeatures\\Microsoft.CodeAnalysis.CSharp.EditorFeatures.dll",
- "Dlls\\CSharpEditorFeatures\\*\\Microsoft.CodeAnalysis.CSharp.EditorFeatures.resources.dll",
- "Dlls\\CSharpFeatures\\Microsoft.CodeAnalysis.CSharp.Features.dll",
- "Dlls\\CSharpFeatures\\*\\Microsoft.CodeAnalysis.CSharp.Features.resources.dll",
- "Dlls\\CSharpInteractiveEditorFeatures\\Microsoft.CodeAnalysis.CSharp.InteractiveEditorFeatures.dll",
- "Dlls\\CSharpInteractiveEditorFeatures\\*\\Microsoft.CodeAnalysis.CSharp.InteractiveEditorFeatures.resources.dll",
- "Dlls\\CSharpScripting\\Microsoft.CodeAnalysis.CSharp.Scripting.dll",
- "Dlls\\CSharpScripting\\*\\Microsoft.CodeAnalysis.CSharp.Scripting.resources.dll",
- "Dlls\\CSharpVisualStudioRepl\\Microsoft.VisualStudio.CSharp.Repl.dll",
- "Dlls\\CSharpVisualStudioRepl\\*\\Microsoft.VisualStudio.CSharp.Repl.resources.dll",
- "Dlls\\CSharpVisualStudio\\Microsoft.VisualStudio.LanguageServices.CSharp.dll",
- "Dlls\\CSharpVisualStudio\\*\\Microsoft.VisualStudio.LanguageServices.CSharp.resources.dll",
- "Dlls\\CSharpWorkspace\\Microsoft.CodeAnalysis.CSharp.Workspaces.dll",
- "Dlls\\CSharpWorkspace\\*\\Microsoft.CodeAnalysis.CSharp.Workspaces.resources.dll",
- "Dlls\\CodeAnalysis\\Microsoft.CodeAnalysis.dll",
- "Dlls\\CodeAnalysis\\*\\Microsoft.CodeAnalysis.resources.dll",
- "Dlls\\CodeStyle\\Microsoft.CodeAnalysis.CodeStyle.dll",
- "Dlls\\CodeStyle\\*\\Microsoft.CodeAnalysis.CodeStyle.resources.dll",
- "Dlls\\CodeStyleFixes\\Microsoft.CodeAnalysis.CodeStyle.Fixes.dll",
- "Dlls\\CodeStyleFixes\\*\\Microsoft.CodeAnalysis.CodeStyle.Fixes.resources.dll",
- "Dlls\\Diagnostics\\Roslyn.Hosting.Diagnostics.dll",
- "Dlls\\EditorFeatures\\Microsoft.CodeAnalysis.EditorFeatures.dll",
- "Dlls\\EditorFeatures\\*\\Microsoft.CodeAnalysis.EditorFeatures.resources.dll",
- "Dlls\\EditorFeatures.Wpf\\Microsoft.CodeAnalysis.EditorFeatures.Wpf.dll",
- "Dlls\\EditorFeatures.Wpf\\*\\Microsoft.CodeAnalysis.EditorFeatures.Wpf.resources.dll",
- "Dlls\\Features\\Microsoft.CodeAnalysis.Features.dll",
- "Dlls\\Features\\*\\Microsoft.CodeAnalysis.Features.resources.dll",
- "Dlls\\InteractiveEditorFeatures\\Microsoft.CodeAnalysis.InteractiveEditorFeatures.dll",
- "Dlls\\InteractiveEditorFeatures\\*\\Microsoft.CodeAnalysis.InteractiveEditorFeatures.resources.dll",
- "Dlls\\InteractiveFeatures\\Microsoft.CodeAnalysis.InteractiveFeatures.dll",
- "Dlls\\MSBuildTask\\net46\\Microsoft.Build.Tasks.CodeAnalysis.dll",
- "Dlls\\MSBuildTask\\net46\\*\\Microsoft.Build.Tasks.CodeAnalysis.resources.dll",
- "Dlls\\MSBuildTask\\netcoreapp2.0\\Microsoft.Build.Tasks.CodeAnalysis.dll",
- "Dlls\\MSBuildTask\\netcoreapp2.0\\*\\Microsoft.Build.Tasks.CodeAnalysis.resources.dll",
- "Dlls\\RemoteWorkspaces\\Microsoft.CodeAnalysis.Remote.Workspaces.dll",
- "Dlls\\Scripting\\Microsoft.CodeAnalysis.Scripting.dll",
- "Dlls\\Scripting\\*\\Microsoft.CodeAnalysis.Scripting.resources.dll",
- "Dlls\\ServiceHub\\Microsoft.CodeAnalysis.Remote.ServiceHub.dll",
- "Dlls\\ServicesVisualStudioImpl\\Microsoft.VisualStudio.LanguageServices.Implementation.dll",
- "Dlls\\ServicesVisualStudio\\Microsoft.VisualStudio.LanguageServices.dll",
- "Dlls\\ServicesVisualStudio\\*\\Microsoft.VisualStudio.LanguageServices.resources.dll",
- "Dlls\\SolutionExplorerShim\\Microsoft.VisualStudio.LanguageServices.SolutionExplorer.dll",
- "Dlls\\SolutionExplorerShim\\*\\Microsoft.VisualStudio.LanguageServices.SolutionExplorer.resources.dll",
- "Dlls\\RazorServiceHub\\Microsoft.CodeAnalysis.Remote.Razor.ServiceHub.dll",
- "Dlls\\RazorVisualStudio\\Microsoft.VisualStudio.LanguageServices.Razor.RemoteClient.dll",
- "Dlls\\TextEditorFeatures\\Microsoft.CodeAnalysis.EditorFeatures.Text.dll",
- "Dlls\\TextEditorFeatures\\*\\Microsoft.CodeAnalysis.EditorFeatures.Text.resources.dll",
- "Dlls\\VisualStudioInteractiveServices\\Microsoft.VisualStudio.InteractiveServices.dll",
- "Dlls\\Workspaces.Desktop\\Microsoft.CodeAnalysis.Workspaces.Desktop.dll",
- "Dlls\\Workspaces.Desktop\\*\\Microsoft.CodeAnalysis.Workspaces.Desktop.resources.dll",
- "Dlls\\Workspaces.MSBuild\\Microsoft.CodeAnalysis.Workspaces.MSBuild.dll",
- "Dlls\\Workspaces.MSBuild\\*\\Microsoft.CodeAnalysis.Workspaces.MSBuild.resources.dll",
- "Dlls\\Workspaces\\Microsoft.CodeAnalysis.Workspaces.dll",
- "Dlls\\Workspaces\\*\\Microsoft.CodeAnalysis.Workspaces.resources.dll",
- "Dlls\\XamlVisualStudio\\Microsoft.VisualStudio.LanguageServices.Xaml.dll",
- "Dlls\\XamlVisualStudio\\*\\Microsoft.VisualStudio.LanguageServices.Xaml.resources.dll",
- "Exes\\InteractiveHost32\\InteractiveHost32.exe",
- "Exes\\InteractiveHost64\\InteractiveHost64.exe",
- "Exes\\VBCSCompiler\\net46\\VBCSCompiler.exe",
- "Exes\\VBCSCompiler\\netcoreapp2.0\\VBCSCompiler.dll",
- "Exes\\csc\\net46\\csc.exe",
- "Exes\\csc\\netcoreapp2.0\\csc.dll",
- "Exes\\csi\\net46\\csi.exe",
- "Exes\\csi\\netcoreapp2.0\\csi.dll",
- "Exes\\vbc\\net46\\vbc.exe",
- "Exes\\vbc\\netcoreapp2.0\\vbc.dll",
- "Exes\\vbi\\net46\\vbi.exe",
- "Exes\\vbi\\netcoreapp2.0\\vbi.dll",
- "Vsix\\CompilerExtension\\Roslyn.Compilers.Extension.dll",
- "Vsix\\VisualStudioDiagnosticsWindow\\Roslyn.VisualStudio.DiagnosticsWindow.dll",
- "Vsix\\VisualStudioDiagnosticsWindow\\*\\Roslyn.VisualStudio.DiagnosticsWindow.resources.dll",
- "Vsix\\VisualStudioInteractiveComponents\\Roslyn.VisualStudio.InteractiveComponents.dll"
- ]
- },
- {
- "certificate": "MicrosoftSHA2",
- "strongName": null,
- "values": [
- "Dlls\\ServicesTestUtilities\\Roslyn.Services.Test.Utilities.dll",
- "Dlls\\TestUtilities\\net46\\Roslyn.Test.Utilities.dll",
- "Dlls\\VisualStudioIntegrationTestUtilities\\Microsoft.VisualStudio.IntegrationTest.Utilities.dll",
- "Vsix\\VisualStudioIntegrationTestSetup\\Microsoft.VisualStudio.IntegrationTest.Setup.dll"
- ]
- },
- {
- "certificate": "WindowsPhone623",
- "strongName": "MsSharedLib72",
- "values": [
- "Dlls\\ExpressionCompiler\\Microsoft.CodeAnalysis.ExpressionEvaluator.ExpressionCompiler.dll",
- "Dlls\\FunctionResolver\\Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver.dll",
- "Dlls\\ResultProvider.Portable\\Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.dll",
- "Dlls\\CSharpExpressionCompiler\\Microsoft.CodeAnalysis.CSharp.ExpressionEvaluator.ExpressionCompiler.dll",
- "Dlls\\CSharpResultProvider.Portable\\Microsoft.CodeAnalysis.CSharp.ExpressionEvaluator.ResultProvider.dll",
- "Dlls\\BasicExpressionCompiler\\Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.ExpressionCompiler.dll",
- "Dlls\\BasicResultProvider.Portable\\Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.ResultProvider.dll"
- ]
- },
- {
- "certificate": "MicrosoftSHA1Win8WinBlue",
- "strongName": "MsSharedLib72",
- "values": [
- "Dlls\\ResultProvider.NetFX20\\Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.dll",
- "Dlls\\CSharpResultProvider.NetFX20\\Microsoft.CodeAnalysis.CSharp.ExpressionEvaluator.ResultProvider.dll",
- "Dlls\\BasicResultProvider.NetFX20\\Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator.ResultProvider.dll"
- ]
- },
- {
- "certificate": "VsixSHA2",
- "strongName": null,
- "values": [
- "Vsix\\ExpressionEvaluatorPackage\\ExpressionEvaluatorPackage.vsix",
- "Vsix\\CompilerExtension\\Roslyn.Compilers.Extension.vsix",
- "Vsix\\VisualStudioDiagnosticsWindow\\Roslyn.VisualStudio.DiagnosticsWindow.vsix",
- "Vsix\\VisualStudioInteractiveComponents\\Roslyn.VisualStudio.InteractiveComponents.vsix",
- "Vsix\\VisualStudioSetup\\Roslyn.VisualStudio.Setup.vsix",
- "Vsix\\Roslyn\\RoslynDeployment.vsix",
- "Vsix\\VisualStudioIntegrationTestSetup\\Microsoft.VisualStudio.IntegrationTest.Setup.vsix",
- "Vsix\\CodeAnalysisCompilers\\Microsoft.CodeAnalysis.Compilers.vsix",
- "Vsix\\PortableFacades\\PortableFacades.vsix"
- ]
- },
- {
- "certificate": "NuGet",
- "strongName": null,
- "values": [
- "Nuget\\PerBuildPreRelease\\*.nupkg",
- "Nuget\\PreRelease\\*.nupkg",
- "Nuget\\Release\\*.nupkg"
- ]
- }
- ],
-
- "exclude": [
- "e_sqlite3.dll",
- "Humanizer.dll",
- "Humanizer.resources.dll",
- "ICSharpCode.Decompiler.dll",
- "Microsoft.Build.Conversion.Core.dll",
- "Microsoft.Build.Engine.dll",
- "Microsoft.Build.Framework.dll",
- "Microsoft.Build.Tasks.Core.dll",
- "Microsoft.Build.Utilities.Core.dll",
- "Microsoft.Build.dll",
- "Microsoft.CodeAnalysis.Analyzers.1.1.0.nupkg",
- "Microsoft.CodeAnalysis.CSharp.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.CSharp.Workspaces.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.Common.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.Elfie.dll",
- "Microsoft.CodeAnalysis.VisualBasic.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.VisualBasic.Workspaces.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.Workspaces.Common.1.0.1.nupkg",
- "Microsoft.Diagnostics.Runtime.dll",
- "Microsoft.DiaSymReader.Native.amd64.dll",
- "Microsoft.DiaSymReader.Native.arm.dll",
- "Microsoft.DiaSymReader.Native.x86.dll",
- "Microsoft.DiaSymReader.dll",
- "Microsoft.VisualStudio.Threading.dll",
- "Microsoft.VisualStudio.Threading.resources.dll",
- "Microsoft.VisualStudio.Validation.dll",
- "Microsoft.Win32.Primitives.dll",
- "Mono.Cecil.dll",
- "Mono.Cecil.Mdb.dll",
- "Mono.Cecil.Pdb.dll",
- "Mono.Cecil.Rocks.dll",
- "Nerdbank.FullDuplexStream.dll",
- "Newtonsoft.Json.dll",
- "NuGet.CommandLine.2.8.5.nupkg",
- "SQLitePCLRaw.batteries_green.dll",
- "SQLitePCLRaw.batteries_v2.dll",
- "SQLitePCLRaw.core.dll",
- "SQLitePCLRaw.provider.e_sqlite3.dll",
- "StreamJsonRpc.dll",
- "StreamJsonRpc.resources.dll",
- "System.AppContext.dll",
- "System.Buffers.dll",
- "System.Collections.Concurrent.dll",
- "System.Collections.NonGeneric.dll",
- "System.Collections.Specialized.dll",
- "System.Collections.Immutable.1.1.36.nupkg",
- "System.Collections.Immutable.dll",
- "System.Composition.1.0.31.nupkg",
- "System.Composition.AttributedModel.dll",
- "System.Composition.Convention.dll",
- "System.Composition.Hosting.dll",
- "System.Composition.Runtime.dll",
- "System.Composition.TypedParts.dll",
- "System.Console.dll",
- "System.Diagnostics.DiagnosticSource.dll",
- "System.Diagnostics.FileVersionInfo.dll",
- "System.Diagnostics.Process.dll",
- "System.Diagnostics.StackTrace.dll",
- "System.Globalization.Calendars.dll",
- "System.Globalization.Extensions.dll",
- "System.IO.Compression.dll",
- "System.IO.Compression.ZipFile.dll",
- "System.IO.FileSystem.DriveInfo.dll",
- "System.IO.FileSystem.Primitives.dll",
- "System.IO.FileSystem.dll",
- "System.IO.Pipes.AccessControl.dll",
- "System.IO.Pipes.dll",
- "System.IO.dll",
- "System.Net.Http.dll",
- "System.Net.Security.dll",
- "System.Net.Sockets.dll",
- "System.Reflection.Metadata.1.0.21.nupkg",
- "System.Reflection.Metadata.dll",
- "System.Reflection.TypeExtensions.dll",
- "System.Reflection.dll",
- "System.Resources.Reader.dll",
- "System.Runtime.InteropServices.RuntimeInformation.dll",
- "System.Runtime.Serialization.Primitives.dll",
- "System.Security.AccessControl.dll",
- "System.Security.Claims.dll",
- "System.Security.Cryptography.Algorithms.dll",
- "System.Security.Cryptography.Csp.dll",
- "System.Security.Cryptography.Encoding.dll",
- "System.Security.Cryptography.Primitives.dll",
- "System.Security.Cryptography.X509Certificates.dll",
- "System.Security.Principal.dll",
- "System.Security.Principal.Windows.dll",
- "System.Text.Encoding.CodePages.dll",
- "System.Threading.dll",
- "System.Threading.Overlapped.dll",
- "System.Threading.Tasks.Extensions.dll",
- "System.Threading.Thread.dll",
- "System.ValueTuple.dll",
- "System.Xml.ReaderWriter.dll",
- "System.Xml.XPath.XDocument.dll",
- "System.Xml.XPath.dll",
- "System.Xml.XmlDocument.dll",
- "Validation.dll",
- "Microsoft.CodeAnalysis.Analyzers.1.1.0.nupkg",
- "Microsoft.CodeAnalysis.Common.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.CSharp.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.CSharp.Workspaces.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.VisualBasic.Workspaces.1.0.1.nupkg",
- "Microsoft.CodeAnalysis.Workspaces.Common.1.0.1.nupkg",
- "System.Collections.Immutable.1.1.36.nupkg",
- "System.Composition.1.0.31.nupkg",
- "System.Reflection.Metadata.1.0.21.nupkg",
- "Microsoft.CodeAnalysis.VisualBasic.1.0.1.nupkg",
- "NuGet.CommandLine.2.8.5.nupkg"
- ]
-}
diff --git a/build/config/myget_org-extensions.config b/build/config/myget_org-extensions.config
new file mode 100644
index 0000000000000..fc267789f5c3f
--- /dev/null
+++ b/build/config/myget_org-extensions.config
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/build/scripts/build-utils.ps1 b/build/scripts/build-utils.ps1
index f90a0fd0edf64..4a04080482df5 100644
--- a/build/scripts/build-utils.ps1
+++ b/build/scripts/build-utils.ps1
@@ -354,7 +354,7 @@ function Test-SupportedVisualStudioVersion([string]$version) {
# meets our minimal requirements for the Roslyn repo.
function Get-VisualStudioDirAndId() {
$vswhere = Join-Path (Ensure-BasicTool "vswhere") "tools\vswhere.exe"
- $output = Exec-Command $vswhere "-requires Microsoft.Component.MSBuild -format json" | Out-String
+ $output = Exec-Command $vswhere "-prerelease -requires Microsoft.Component.MSBuild -format json" | Out-String
$j = ConvertFrom-Json $output
foreach ($obj in $j) {
diff --git a/build/scripts/build.ps1 b/build/scripts/build.ps1
index 1e4e888321fb5..7e5fdf5e6bccb 100644
--- a/build/scripts/build.ps1
+++ b/build/scripts/build.ps1
@@ -26,13 +26,11 @@ param (
[switch]$bootstrap = $false,
[switch]$sign = $false,
[switch]$pack = $false,
- [switch]$packAll = $false,
[switch]$binaryLog = $false,
[switch]$deployExtensions = $false,
[switch]$launch = $false,
[switch]$procdump = $false,
[string]$signType = "",
- [switch]$skipBuildExtras = $false,
[switch]$skipAnalyzers = $false,
[switch]$checkLoc = $false,
@@ -62,12 +60,11 @@ function Print-Usage() {
Write-Host " -bootstrap Build using a bootstrap Roslyn"
Write-Host " -sign Sign our binaries"
Write-Host " -signType Type of sign: real, test, verify"
- Write-Host " -pack Create our NuGet packages"
+ Write-Host " -pack Build NuGet packages, VS insertion manifests and installer"
Write-Host " -deployExtensions Deploy built vsixes"
Write-Host " -binaryLog Create binary log for every MSBuild invocation"
Write-Host " -procdump Monitor test runs with procdump"
Write-Host " -skipAnalyzers Do not run analyzers during build operations"
- Write-Host " -skipBuildExtras Do not build insertion items"
Write-Host " -checkLoc Check that all resources are localized"
Write-Host ""
Write-Host "Test options"
@@ -109,7 +106,7 @@ function Process-Arguments() {
exit 1
}
- if (($cibuild -and $anyVsi)) {
+ if ($cibuild -and -not $official -and $anyVsi) {
# Avoid spending time in analyzers when requested, and also in the slowest integration test builds
$script:skipAnalyzers = $true
}
@@ -124,9 +121,6 @@ function Process-Arguments() {
exit 1
}
- $script:pack = $pack -or $packAll
- $script:packAll = $packAll -or ($pack -and $official)
-
if ($buildCoreClr) {
$script:build = $true
}
@@ -166,7 +160,11 @@ function Run-MSBuild([string]$projectFilePath, [string]$buildArgs = "", [string]
}
if ($official) {
- $args += " /p:OfficialBuild=true"
+ $args += " /p:OfficialBuildId=" + $env:BUILD_BUILDNUMBER
+ }
+
+ if ($cibuild) {
+ $args += " /p:ContinuousIntegrationBuild=true"
}
if ($bootstrapDir -ne "") {
@@ -208,158 +206,66 @@ function Restore-Packages() {
# Important to not set $script:bootstrapDir here yet as we're actually in the process of
# building the bootstrap.
function Make-BootstrapBuild() {
+ Write-Host "Building bootstrap compiler"
+
$dir = Join-Path $binariesDir "Bootstrap"
- Write-Host "Building Bootstrap compiler"
- $bootstrapArgs = "/p:UseShippingAssemblyVersion=true /p:InitialDefineConstants=BOOTSTRAP"
Remove-Item -re $dir -ErrorAction SilentlyContinue
Create-Directory $dir
- if ($buildCoreClr) {
- $bootstrapFramework = "netcoreapp2.0"
- $projectFiles = @(
- 'src/Compilers/CSharp/csc/csc.csproj',
- 'src/Compilers/VisualBasic/vbc/vbc.csproj',
- 'src/Compilers/Server/VBCSCompiler/VBCSCompiler.csproj',
- 'src/Compilers/Core/MSBuildTask/MSBuildTask.csproj'
- )
-
- foreach ($projectFilePath in $projectFiles) {
- $fileName = [IO.Path]::GetFileNameWithoutExtension((Split-Path -leaf $projectFilePath))
- $logFileName = "Bootstrap$($fileName)"
- Run-MSBuild $projectFilePath "/t:Publish /p:TargetFramework=netcoreapp2.0 $bootstrapArgs" -logFileName $logFileName -useDotnetBuild
- }
- Pack-One "Microsoft.NetCore.Compilers.nuspec" "Bootstrap" $dir
- Unzip-File "$dir\Microsoft.NETCore.Compilers.42.42.42.42-bootstrap.nupkg" "$dir\Microsoft.NETCore.Compilers\42.42.42.42"
+ $packageName = if ($buildCoreClr) { "Microsoft.NETCore.Compilers" } else { "Microsoft.Net.Compilers" }
+ $projectPath = "src\NuGet\$packageName\$packageName.Package.csproj"
- Write-Host "Cleaning Bootstrap compiler artifacts"
- Run-MSBuild "Compilers.sln" "/t:Clean"
- Stop-BuildProcesses
- }
- else {
- Run-MSBuild "build\Toolset\Toolset.csproj" $bootstrapArgs -logFileName "Bootstrap"
- Remove-Item -re $dir -ErrorAction SilentlyContinue
- Create-Directory $dir
+ Run-MSBuild $projectPath "/t:Pack /p:DotNetUseShippingVersions=true /p:InitialDefineConstants=BOOTSTRAP /p:PackageOutputPath=$dir" -logFileName "Bootstrap" -useDotnetBuild:$buildCoreClr
+ $packageFile = Get-ChildItem -Path $dir -Filter "$packageName.*.nupkg"
+ Unzip-File "$dir\$packageFile" $dir
- Pack-One "Microsoft.Net.Compilers.nuspec" "Bootstrap" $dir
- Unzip-File "$dir\Microsoft.Net.Compilers.42.42.42.42-bootstrap.nupkg" "$dir\Microsoft.Net.Compilers\42.42.42.42"
-
- Write-Host "Cleaning Bootstrap compiler artifacts"
- Run-MSBuild "build\Toolset\Toolset.csproj" "/t:Clean" -logFileName "BootstrapClean"
- Stop-BuildProcesses
- }
+ Write-Host "Cleaning Bootstrap compiler artifacts"
+ Run-MSBuild $projectPath "/t:Clean" -logFileName "BootstrapClean"
return $dir
}
function Build-Artifacts() {
+ $args = "/t:Build"
+ if ($pack) { $args += " /t:Pack" }
+ if (-not $deployExtensions) { $args += " /p:DeployExtension=false" }
+
if ($buildCoreClr) {
- Run-MSBuild "Compilers.sln" -useDotnetBuild
+ Run-MSBuild "Compilers.sln" $args -useDotnetBuild
}
elseif ($build) {
- Run-MSBuild "Roslyn.sln" $(if (-not $deployExtensions) {"/p:DeployExtension=false"})
- if (-not $skipBuildExtras) {
- Build-ExtraSignArtifacts
- }
+ Run-MSBuild "Roslyn.sln" $args
}
if ($pack) {
- Build-NuGetPackages
+ Run-MSBuild "build\Targets\RepoToolset\AfterSolutionBuild.proj" "/t:Pack"
}
if ($sign) {
- Run-SignTool
+ Run-MSBuild "build\Targets\RepoToolset\Sign.proj" "/p:DotNetSignType=$signType"
+ }
+
+ if ($pack) {
+ Run-MSBuild "build\Targets\RepoToolset\AfterSigning.proj" "/t:Pack"
}
- if ($pack -and ($cibuild -or $official)) {
+ if ($pack -and $cibuild) {
Build-DeployToSymStore
}
- if ($build -and (-not $skipBuildExtras) -and (-not $buildCoreClr)) {
+ if ($build -and $pack -and (-not $buildCoreClr)) {
Build-InsertionItems
Build-Installer
}
}
-# Not all of our artifacts needed for signing are included inside Roslyn.sln. Need to
-# finish building these before we can run signing.
-function Build-ExtraSignArtifacts() {
-
- Push-Location (Join-Path $repoDir "src\Setup")
- try {
- # Publish the CoreClr projects (CscCore and VbcCore) and dependencies for later NuGet packaging.
- Write-Host "Publishing csc"
- Run-MSBuild "..\Compilers\CSharp\csc\csc.csproj" "/p:TargetFramework=netcoreapp2.0 /t:PublishWithoutBuilding"
- Write-Host "Publishing vbc"
- Run-MSBuild "..\Compilers\VisualBasic\vbc\vbc.csproj" "/p:TargetFramework=netcoreapp2.0 /t:PublishWithoutBuilding"
- Write-Host "Publishing VBCSCompiler"
- Run-MSBuild "..\Compilers\Server\VBCSCompiler\VBCSCompiler.csproj" "/p:TargetFramework=netcoreapp2.0 /t:PublishWithoutBuilding"
- Write-Host "Publishing MSBuildTask"
- Run-MSBuild "..\Compilers\Core\MSBuildTask\MSBuildTask.csproj" "/p:TargetFramework=netcoreapp2.0 /t:PublishWithoutBuilding"
- Write-Host "Building PortableFacades Swix"
- Run-MSBuild "DevDivVsix\PortableFacades\PortableFacades.swixproj"
- Write-Host "Building CompilersCodeAnalysis Swix"
- Run-MSBuild "DevDivVsix\CompilersPackage\Microsoft.CodeAnalysis.Compilers.swixproj"
-
- $dest = @($configDir)
- foreach ($dir in $dest) {
- Copy-Item "PowerShell\*.ps1" $dir
- }
-
- Copy-Item -Force "Vsix\myget_org-extensions.config" $configDir
- }
- finally {
- Pop-Location
- }
-}
-
function Build-InsertionItems() {
- # Create the PerfTests directory under Binaries\$(Configuration). There are still a number
- # of tools (in roslyn and roslyn-internal) that depend on this combined directory.
- function Create-PerfTests() {
- $target = Join-Path $configDir "PerfTests"
- Write-Host "PerfTests: $target"
- Create-Directory $target
-
- Push-Location $configDir
- foreach ($subDir in @("Dlls", "UnitTests")) {
- Push-Location $subDir
- foreach ($path in Get-ChildItem -re -in "PerfTests") {
- Write-Host "`tcopying $path"
- Copy-Item -force -recurse "$path\*" $target
- }
- Pop-Location
- }
- Pop-Location
- }
-
$setupDir = Join-Path $repoDir "src\Setup"
Push-Location $setupDir
try {
- Create-PerfTests
- Exec-Console (Join-Path $configDir "Exes\DevDivInsertionFiles\Roslyn.BuildDevDivInsertionFiles.exe") "$configDir $repoDir $(Get-PackagesDir)"
-
- # In non-official builds need to supply values for a few MSBuild properties. The actual value doesn't
- # matter, just that it's provided some value.
- $extraArgs = ""
- if (-not $official) {
- $extraArgs = " /p:FinalizeValidate=false /p:ManifestPublishUrl=https://vsdrop.corp.microsoft.com/file/v1/Products/DevDiv/dotnet/roslyn/master/20160729.6"
- }
-
- $insertionDir = Join-Path $configDir "DevDivInsertionFiles"
- $vsToolsDir = Join-Path $insertionDir "VS.Tools.Roslyn"
- $packageOutDir = Join-Path $configDir "DevDivPackages\Roslyn"
- $packArgs = "/p:NoPackageAnalysis=true"
- Create-Directory $packageOutDir
- Pack-One (Join-Path $insertionDir "VS.ExternalAPIs.Roslyn.nuspec") "PerBuildPreRelease" $packageOutDir $packArgs
- Pack-One (Join-Path $vsToolsDir "VS.Tools.Roslyn.nuspec") "PerBuildPreRelease" $packageOutDir $packArgs -basePath $vsToolsDir
-
- $netfx20Dir = Join-Path $repoDir "src\Dependencies\Microsoft.NetFX20"
- Pack-One (Join-Path $netfx20Dir "Microsoft.NetFX20.nuspec") "PerBuildPreRelease" -packageOutDir (Join-Path $configDir "NuGet\NetFX20") -basePath $netfx20Dir -extraArgs "$packArgs /p:CurrentVersion=4.3.0"
-
- Run-MSBuild "DevDivVsix\PortableFacades\PortableFacades.vsmanproj" -buildArgs $extraArgs
- Run-MSBuild "DevDivVsix\CompilersPackage\Microsoft.CodeAnalysis.Compilers.vsmanproj" -buildArgs $extraArgs
- Run-MSBuild "DevDivVsix\MicrosoftCodeAnalysisLanguageServices\Microsoft.CodeAnalysis.LanguageServices.vsmanproj" -buildArgs "$extraArgs"
+ Write-Host "Building VS Insertion artifacts"
+ Exec-Console (Join-Path $configDir "Exes\Roslyn.BuildDevDivInsertionFiles\Roslyn.BuildDevDivInsertionFiles.exe") "$configDir $(Get-PackagesDir)"
}
finally {
Pop-Location
@@ -367,19 +273,21 @@ function Build-InsertionItems() {
}
function Build-Installer () {
- # Copying Artifacts
+ ## Copying Artifacts
$installerDir = Join-Path $configDir "Installer"
+ if (Test-Path $installerDir) {
+ Remove-Item -Path $installerDir -Recurse -Force
+ }
Create-Directory $installerDir
$intermidateDirectory = Join-Path $env:TEMP "InstallerTemp"
- if(Test-Path $intermidateDirectory)
- {
+ if (Test-Path $intermidateDirectory) {
Remove-Item -Path $intermidateDirectory -Recurse -Force
}
- New-Item -ItemType Directory -Force -Path $intermidateDirectory
+ Create-Directory $intermidateDirectory
## Copying VsixExpInstaller.exe
- $vsixExpInstallerDir = Get-PackageDir "RoslynTools.Microsoft.VSIXExpInstaller"
+ $vsixExpInstallerDir = Get-PackageDir "RoslynTools.VSIXExpInstaller"
$vsixExpInstallerExe = Join-Path $vsixExpInstallerDir "tools\*"
$vsixExpInstallerExeDestination = Join-Path $intermidateDirectory "tools\vsixexpinstaller"
Create-Directory $vsixExpInstallerExeDestination
@@ -400,12 +308,11 @@ function Build-Installer () {
Copy-Item $installerScriptsFolder -Destination $intermidatePowershellScriptsDirectory -Recurse
## Copying VSIXes
- $vsixDir = Join-Path $configDir "Vsix"
$vsixDirDestination = Join-Path $intermidateDirectory "vsix"
if (-not (Test-Path $vsixDirDestination)) {
New-Item -ItemType Directory -Force -Path $vsixDirDestination
}
- $RoslynDeploymentVsix = Join-Path $vsixDir "Roslyn\RoslynDeployment.vsix"
+ $RoslynDeploymentVsix = Join-Path $vsSetupDir "RoslynDeployment.vsix"
Copy-Item $RoslynDeploymentVsix -Destination $vsixDirDestination
# Zip Folder
@@ -414,69 +321,6 @@ function Build-Installer () {
Compress-Archive -Path $intermidateDirectory -DestinationPath $installerZip
}
-function Pack-One([string]$nuspecFilePath, [string]$packageKind, [string]$packageOutDir = "", [string]$extraArgs = "", [string]$basePath = "", [switch]$useConsole = $true) {
- $nugetDir = Join-Path $repoDir "src\Nuget"
- if ($packageOutDir -eq "") {
- $packageOutDir = Join-Path $configDir "NuGet\$packageKind"
- }
-
- if ($basePath -eq "") {
- $basePath = $configDir
- }
-
- if (-not ([IO.Path]::IsPathRooted($nuspecFilePath))) {
- $nuspecFilePath = Join-Path $nugetDir $nuspecFilePath
- }
-
- Create-Directory $packageOutDir
- $nuspecFileName = Split-Path -leaf $nuspecFilePath
- $projectFilePath = Join-Path $nugetDir "NuGetProjectPackUtil.csproj"
- $packArgs = "pack -nologo --no-build $projectFilePath $extraArgs /p:NugetPackageKind=$packageKind /p:NuspecFile=$nuspecFilePath /p:NuspecBasePath=$basePath -o $packageOutDir"
-
- if ($official) {
- $packArgs = "$packArgs /p:OfficialBuild=true"
- }
-
- if ($useConsole) {
- Exec-Console $dotnet $packArgs
- }
- else {
- Exec-Command $dotnet $packArgs
- }
-}
-
-function Build-NuGetPackages() {
-
- function Pack-All([string]$packageKind, $extraArgs) {
-
- Write-Host "Packing for $packageKind"
- foreach ($item in Get-ChildItem *.nuspec) {
- $name = Split-Path -leaf $item
- Pack-One $name $packageKind -extraArgs $extraArgs
- }
- }
-
- Push-Location (Join-Path $repoDir "src\NuGet")
- try {
- $extraArgs = ""
-
- # Empty directory for packing explicit empty items in the nuspec
- $emptyDir = Join-Path ([IO.Path]::GetTempPath()) ([IO.Path]::GetRandomFileName())
- Create-Directory $emptyDir
- New-Item -Path (Join-Path $emptyDir "_._") -Type File | Out-Null
- $extraArgs += " /p:EmptyDir=$emptyDir"
-
- Pack-All "PreRelease" $extraArgs
- if ($packAll) {
- Pack-All "Release" $extraArgs
- Pack-All "PerBuildPreRelease" $extraArgs
- }
- }
- finally {
- Pop-Location
- }
-}
-
function Build-DeployToSymStore() {
Run-MSBuild "Roslyn.sln" "/t:DeployToSymStore" -logFileName "RoslynDeployToSymStore"
}
@@ -571,14 +415,14 @@ function Test-XUnit() {
$dlls = Get-ChildItem -re -in "*.UnitTests.dll" $unitDir
}
else {
- $dlls = Get-ChildItem -re -in "*.UnitTests.dll" -ex "*Roslyn.Interactive*" $unitDir
+ $dlls = Get-ChildItem -re -in "*.UnitTests.dll" -ex "*InteractiveHost*" $unitDir
}
}
elseif ($testVsi) {
# Since they require Visual Studio to be installed, ensure that the MSBuildWorkspace tests run along with our VS
# integration tests in CI.
if ($cibuild) {
- $dlls += @(Get-Item (Join-Path $unitDir "Workspaces.MSBuild.Test\Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.dll"))
+ $dlls += @(Get-Item (Join-Path $unitDir "Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests\Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.dll"))
}
$dlls += @(Get-ChildItem -re -in "*.IntegrationTests.dll" $unitDir)
@@ -595,7 +439,7 @@ function Test-XUnit() {
$dlls = $dlls | ?{ -not ($_.FullName -match ".*\\ref\\.*") }
$dlls = $dlls | ?{ -not ($_.FullName -match ".*/ref/.*") }
- if ($cibuild -or $official) {
+ if ($cibuild) {
# Use a 75 minute timeout on CI
$args += " -xml -timeout:75"
}
@@ -626,8 +470,8 @@ function Test-XUnit() {
# Deploy our core VSIX libraries to Visual Studio via the Roslyn VSIX tool. This is an alternative to
# deploying at build time.
-function Deploy-VsixViaTool() {
- $vsixDir = Get-PackageDir "RoslynTools.Microsoft.VSIXExpInstaller"
+function Deploy-VsixViaTool() {
+ $vsixDir = Get-PackageDir "RoslynTools.VSIXExpInstaller"
$vsixExe = Join-Path $vsixDir "tools\VsixExpInstaller.exe"
$both = Get-VisualStudioDirAndId
$vsDir = $both[0].Trim("\")
@@ -635,14 +479,6 @@ function Deploy-VsixViaTool() {
$hive = "RoslynDev"
Write-Host "Using VS Instance $vsId at `"$vsDir`""
$baseArgs = "/rootSuffix:$hive /vsInstallDir:`"$vsDir`""
- $all = @(
- "Vsix\CompilerExtension\Roslyn.Compilers.Extension.vsix",
- "Vsix\VisualStudioSetup\Roslyn.VisualStudio.Setup.vsix",
- "Vsix\VisualStudioInteractiveComponents\Roslyn.VisualStudio.InteractiveComponents.vsix",
- "Vsix\ExpressionEvaluatorPackage\ExpressionEvaluatorPackage.vsix",
- "Vsix\VisualStudioDiagnosticsWindow\Roslyn.VisualStudio.DiagnosticsWindow.vsix",
- "Vsix\VisualStudioSetup.Dependencies\Roslyn.VisualStudio.Setup.Dependencies.vsix",
- "Vsix\VisualStudioIntegrationTestSetup\Microsoft.VisualStudio.IntegrationTest.Setup.vsix")
Write-Host "Uninstalling old Roslyn VSIX"
@@ -658,35 +494,22 @@ function Deploy-VsixViaTool() {
}
Write-Host "Installing all Roslyn VSIX"
- foreach ($e in $all) {
- $name = Split-Path -leaf $e
- $filePath = Join-Path $configDir $e
- $fullArg = "$baseArgs $filePath"
- Write-Host "`tInstalling $name"
- Exec-Console $vsixExe $fullArg
- }
-}
-
-# Sign all of our binaries that need to be signed
-function Run-SignTool() {
- Push-Location $repoDir
- try {
- $signTool = Join-Path (Get-PackageDir "RoslynTools.SignTool") "tools\SignTool.exe"
- $signToolArgs = "-msbuildPath `"$msbuild`""
- if ($binaryLog) {
- $signToolArgs += " -msbuildBinaryLog $logsDir\Signing.binlog"
- }
- switch ($signType) {
- "real" { break; }
- "test" { $signToolArgs += " -testSign"; break; }
- default { $signToolArgs += " -test"; break; }
- }
- $signToolArgs += " `"$configDir`""
- Exec-Console $signTool $signToolArgs
- }
- finally {
- Pop-Location
+ # VSIX files need to be installed in this specific order:
+ $orderedVsixFileNames = @(
+ "Roslyn.Compilers.Extension.vsix",
+ "Roslyn.VisualStudio.Setup.vsix",
+ "Roslyn.VisualStudio.Setup.Dependencies.vsix",
+ "Roslyn.VisualStudio.InteractiveComponents.vsix",
+ "ExpressionEvaluatorPackage.vsix",
+ "Roslyn.VisualStudio.DiagnosticsWindow.vsix",
+ "Microsoft.VisualStudio.IntegrationTest.Setup.vsix")
+
+ foreach ($vsixFileName in $orderedVsixFileNames) {
+ $vsixFile = Join-Path $vsSetupDir $vsixFileName
+ $fullArg = "$baseArgs $vsixFile"
+ Write-Host "`tInstalling $vsixFileName"
+ Exec-Console $vsixExe $fullArg
}
}
@@ -726,6 +549,7 @@ function Redirect-Temp() {
Copy-Item (Join-Path $repoDir "src\Workspaces\CoreTestUtilities\Resources\Directory.Build.props") $temp
Copy-Item (Join-Path $repoDir "src\Workspaces\CoreTestUtilities\Resources\Directory.Build.targets") $temp
Copy-Item (Join-Path $repoDir "src\Workspaces\CoreTestUtilities\Resources\Directory.Build.rsp") $temp
+ Copy-Item (Join-Path $repoDir "src\Workspaces\CoreTestUtilities\Resources\NuGet.Config") $temp
${env:TEMP} = $temp
${env:TMP} = $temp
}
@@ -774,6 +598,7 @@ try {
$dotnet = Ensure-DotnetSdk
$buildConfiguration = if ($release) { "Release" } else { "Debug" }
$configDir = Join-Path $binariesDir $buildConfiguration
+ $vsSetupDir = Join-Path $binariesDir (Join-Path "VSSetup" $buildConfiguration)
$logsDir = Join-Path $configDir "Logs"
$bootstrapDir = ""
@@ -830,8 +655,8 @@ catch {
}
finally {
Pop-Location
- if ($cibuild) {
+ if ($cibuild -and -not $official) {
Stop-VSProcesses
Stop-BuildProcesses
}
-}
+}
\ No newline at end of file
diff --git a/build/scripts/cibuild.cmd b/build/scripts/cibuild.cmd
index 1551ffc63a6cc..b4dc8daa4b4b5 100644
--- a/build/scripts/cibuild.cmd
+++ b/build/scripts/cibuild.cmd
@@ -1,2 +1,2 @@
@echo off
-powershell -noprofile -executionPolicy RemoteSigned -file "%~dp0\build.ps1" -cibuild -build -restore -bootstrap -binaryLog %*
+powershell -noprofile -executionPolicy RemoteSigned -file "%~dp0\build.ps1" -cibuild -build -restore -bootstrap -pack -binaryLog %*
diff --git a/build/scripts/cibuild.sh b/build/scripts/cibuild.sh
index 1d028504b4841..320eff72559c3 100755
--- a/build/scripts/cibuild.sh
+++ b/build/scripts/cibuild.sh
@@ -16,7 +16,7 @@ then
export HOME="$(cd ~ && pwd)"
fi
-# There's no reason to send telemetry or prime a local package cach when building
+# There's no reason to send telemetry or prime a local package cache when building
# in CI.
export DOTNET_CLI_TELEMETRY_OPTOUT=1
export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
@@ -24,4 +24,4 @@ export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
echo "Building this commit:"
git show --no-patch --pretty=raw HEAD
-"${root_path}"/build.sh --restore --bootstrap --build --packall --stop-vbcscompiler --test "$@"
+"${root_path}"/build.sh --restore --bootstrap --build --pack --stop-vbcscompiler --test "$@"
diff --git a/build/scripts/docker/Dockerfile b/build/scripts/docker/Dockerfile
index f83c545ffeb62..ada0b61b27a81 100644
--- a/build/scripts/docker/Dockerfile
+++ b/build/scripts/docker/Dockerfile
@@ -33,10 +33,10 @@ RUN apt-get install -y libunwind8 \
# Install Mono
RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF && \
- (echo "deb http://download.mono-project.com/repo/ubuntu stable-xenial/snapshots/5.8.0.108 main" | \
+ (echo "deb http://download.mono-project.com/repo/ubuntu stable-xenial main" | \
tee /etc/apt/sources.list.d/mono-official.list) && \
apt-get update && \
- apt-get install -y mono-devel=5.8.0.108-0xamarin1+ubuntu1604b1 && \
+ apt-get install -y mono-devel && \
apt-get clean
# Setup User to match Host User, and give superuser permissions
diff --git a/build/scripts/test-determinism.ps1 b/build/scripts/test-determinism.ps1
index cd5963864b609..3c3a3509b73c8 100644
--- a/build/scripts/test-determinism.ps1
+++ b/build/scripts/test-determinism.ps1
@@ -1,6 +1,15 @@
+####
+#
+# $bootstrapDir: directory containing the bootstrap compiler
+# $release: whether to build a debug or release build
+# $altRootDrive: the drive we build on (via subst) for verifying pathmap implementation
+#
+####
[CmdletBinding(PositionalBinding=$false)]
param ( [string]$bootstrapDir = "",
- [switch]$debugDeterminism = $false)
+ [switch]$release = $false,
+ [string]$altRootDrive = "q:")
+
Set-StrictMode -version 2.0
$ErrorActionPreference = "Stop"
@@ -12,26 +21,25 @@ $ErrorActionPreference = "Stop"
$script:skipList = @()
# Location that deterministic error information should be written to.
-[string]$script:errorDir = ""
-[string]$script:errorDirLeft = ""
-[string]$script:errorDirRight = ""
+[string]$errorDir = ""
+[string]$errorDirLeft = ""
+[string]$errorDirRight = ""
-function Run-Build([string]$rootDir, [switch]$restore = $false, [string]$logFile = $null) {
+function Run-Build([string]$rootDir, [string]$logFile = $null) {
Push-Location $rootDir
try {
# Clean out the previous run
Write-Host "Cleaning the Binaries"
- Exec-Console $msbuild "/nologo /v:m /nodeReuse:false /t:clean Roslyn.sln"
+ Remove-Item -Recurse (Get-ConfigDir $rootDir)
+ Remove-Item -Recurse (Get-ObjDir $rootDir)
- if ($restore) {
- Write-Host "Restoring the packages"
- Restore-Project $dotnet "Roslyn.sln"
- }
+ Write-Host "Restoring the packages"
+ Restore-Project $dotnet "Roslyn.sln"
- $args = "/nologo /v:m /nodeReuse:false /m /p:DebugDeterminism=true /p:BootstrapBuildPath=$script:bootstrapDir /p:Features=`"debug-determinism`" /p:UseRoslynAnalyzers=false /p:DeployExtension=false Roslyn.sln"
+ $args = "/nologo /v:m /nodeReuse:false /m /p:DebugDeterminism=true /p:ContinuousIntegrationBuild=true /p:BootstrapBuildPath=$script:bootstrapDir /p:Features=`"debug-determinism`" /p:UseRoslynAnalyzers=false /p:DeployExtension=false Roslyn.sln"
if ($logFile -ne $null) {
- $logFile = Join-Path $binariesDir $logFile
+ $logFile = Join-Path $logDir $logFile
$args += " /bl:$logFile"
}
@@ -47,27 +55,45 @@ function Get-ObjDir([string]$rootDir) {
return Join-Path $rootDir "Binaries\Obj"
}
+function Get-ConfigDir([string]$rootDir) {
+ return Join-Path $rootDir "Binaries\$buildConfiguration"
+}
+
# Return all of the files that need to be processed for determinism under the given
# directory.
function Get-FilesToProcess([string]$rootDir) {
$objDir = Get-ObjDir $rootDir
- foreach ($item in Get-ChildItem -re -in *.dll,*.exe,*.pdb $objDir) {
- $fileFullName = $item.FullName
- $fileName = Split-Path -leaf $fileFullName
+ foreach ($item in Get-ChildItem -re -in *.dll,*.exe,*.pdb,*.sourcelink.json $objDir) {
+ $filePath = $item.FullName
+ $fileName = Split-Path -leaf $filePath
if ($skipList.Contains($fileName)) {
continue;
}
- $fileId = $fileFullName.Substring($objDir.Length).Replace("\", ".")
- $fileHash = (Get-FileHash $fileFullName -algorithm MD5).Hash
+ $fileId = $filePath.Substring($objDir.Length).Replace("\", ".")
+ $fileHash = (Get-FileHash $filePath -algorithm MD5).Hash
$data = @{}
$data.Hash = $fileHash
- $data.Content = [IO.File]::ReadAllBytes($fileFullName)
+ $data.Content = [IO.File]::ReadAllBytes($filePath)
$data.FileId = $fileId
$data.FileName = $fileName
- $data.FileFullName = $fileFullName
+ $data.FilePath = $filePath
+
+ $keyFilePath = $filePath + ".key"
+ $keyFileName = Split-Path -leaf $keyFilePath
+ if (Test-Path $keyFilePath) {
+ $data.KeyFileName = $keyFileName
+ $data.KeyFilePath = $keyFilePath
+ $data.KeyFileContent = [IO.File]::ReadAllBytes($keyFilePath)
+ }
+ else {
+ $data.KeyFileName = ""
+ $data.KeyFilePath = ""
+ $data.KeyFileContent = $null
+ }
+
Write-Output $data
}
}
@@ -117,8 +143,8 @@ function Test-MapContents($dataMap) {
}
}
-function Test-Build([string]$rootDir, $dataMap, [string]$logFile, [switch]$restore = $false) {
- Run-Build $rootDir -logFile $logFile -restore:$restore
+function Test-Build([string]$rootDir, $dataMap, [string]$logFile) {
+ Run-Build $rootDir -logFile $logFile
$errorList = @()
$allGood = $true
@@ -127,10 +153,10 @@ function Test-Build([string]$rootDir, $dataMap, [string]$logFile, [switch]$resto
foreach ($fileData in Get-FilesToProcess $rootDir) {
$fileId = $fileData.FileId
$fileName = $fileData.FileName
- $fileFullName = $fileData.FileFullName
+ $filePath = $fileData.FilePath
if (-not $dataMap.Contains($fileId)) {
- Write-Host "ERROR! Missing entry in map $fileId->$fileFullName"
+ Write-Host "ERROR! Missing entry in map $fileId->$filePath"
$allGood = $false
continue
}
@@ -142,8 +168,16 @@ function Test-Build([string]$rootDir, $dataMap, [string]$logFile, [switch]$resto
$errorList += $fileName
# Save out the original and baseline so Jenkins will archive them for investigation
- [IO.File]::WriteAllBytes((Join-Path $script:errorDirLeft $fileName), $oldFileData.Content)
- Copy-Item $fileFullName (Join-Path $script:errorDirRight $fileName)
+ [IO.File]::WriteAllBytes((Join-Path $errorDirLeft $fileName), $oldFileData.Content)
+ Copy-Item $filePath (Join-Path $errorDirRight $fileName)
+
+ # Copy the key files if available too
+ $keyFileName = $oldFileData.KeyFileName
+ if ($keyFileName -ne "") {
+ [IO.File]::WriteAllBytes((Join-Path $errorDirLeft $keyFileName), $oldFileData.KeyFileContent)
+ Copy-Item $fileData.KeyFilePath (Join-Path $errorDirRight $keyFileName)
+ }
+
continue
}
@@ -157,7 +191,7 @@ function Test-Build([string]$rootDir, $dataMap, [string]$logFile, [switch]$resto
}
Write-Host "Archiving failure information"
- $zipFile = Join-Path $repoDir "Binaries\determinism.zip"
+ $zipFile = Join-Path $logDir "determinism.zip"
Add-Type -Assembly "System.IO.Compression.FileSystem";
[System.IO.Compression.ZipFile]::CreateFromDirectory($script:errorDir, $zipFile, "Fastest", $true);
@@ -169,14 +203,6 @@ function Test-Build([string]$rootDir, $dataMap, [string]$logFile, [switch]$resto
function Run-Test() {
$rootDir = $repoDir
- # Ensure the error directory is written for all analysis to use.
- $script:errorDir = Join-Path $repoDir "Binaries\Determinism"
- $script:errorDirLeft = Join-Path $script:errorDir "Left"
- $script:errorDirRight = Join-Path $script:errorDir "Right"
- Create-Directory $script:errorDir
- Create-Directory $script:errorDirLeft
- Create-Directory $script:errorDirRight
-
# Run the initial build so that we can populate the maps
Run-Build $repoDir -logFile "initial.binlog"
$dataMap = Record-Binaries $repoDir
@@ -188,19 +214,30 @@ function Run-Test() {
# Run another build in a different source location and verify that path mapping
# allows the build to be identical. To do this we'll copy the entire source
# tree under the Binaries\q directory and run a build from there.
- $altRootDir = Join-Path "$repoDir\Binaries" "q"
- Remove-Item -re -fo $altRootDir -ErrorAction SilentlyContinue
- & robocopy $repoDir $altRootDir /E /XD $binariesDir /XD ".git" /njh /njs /ndl /nc /ns /np /nfl
-
- # Symlink the .git directory to make SourceLink think Binaries/q is the repo root:
- & cmd /c mklink /d (Join-Path $altRootDir ".git") (Join-Path $repoDir ".git")
-
- Test-Build -rootDir $altRootDir -dataMap $dataMap -logFile "test2.binlog" -restore
+ Write-Host "Building in a different directory"
+ Exec-Command "subst" "$altRootDrive $(Split-Path -parent $repoDir)"
+ try {
+ $altRootDir = Join-Path "$($altRootDrive)\" (Split-Path -leaf $repoDir)
+ Test-Build -rootDir $altRootDir -dataMap $dataMap -logFile "test2.binlog"
+ }
+ finally {
+ Exec-Command "subst" "$altRootDrive /d"
+ }
}
try {
. (Join-Path $PSScriptRoot "build-utils.ps1")
+ # Create all of the logging directories
+ $buildConfiguration = if ($release) { "Release" } else { "Debug" }
+ $logDir = Join-Path (Get-ConfigDir $repoDir) "Logs"
+ $errorDir = Join-Path $binariesDir "Determinism"
+ $errorDirLeft = Join-Path $errorDir "Left"
+ $errorDirRight = Join-Path $errorDir "Right"
+ Create-Directory $logDir
+ Create-Directory $errorDirLeft
+ Create-Directory $errorDirRight
+
$dotnet = Ensure-DotnetSdk
$msbuild = Ensure-MSBuild
if (($bootstrapDir -eq "") -or (-not ([IO.Path]::IsPathRooted($script:bootstrapDir)))) {
diff --git a/build/scripts/tests.sh b/build/scripts/tests.sh
index 6b3e692f643a4..6f101c3f0208f 100755
--- a/build/scripts/tests.sh
+++ b/build/scripts/tests.sh
@@ -16,7 +16,7 @@ binaries_path="${root_path}"/Binaries
unittest_dir="${binaries_path}"/"${build_configuration}"/UnitTests
log_dir="${binaries_path}"/"${build_configuration}"/xUnitResults
nuget_dir="${HOME}"/.nuget/packages
-xunit_console_version="$(get_package_version dotnet-xunit)"
+xunit_console_version="$(get_package_version xunitrunnerconsole)"
if [[ "${runtime}" == "dotnet" ]]; then
target_framework=netcoreapp2.0
@@ -24,8 +24,8 @@ if [[ "${runtime}" == "dotnet" ]]; then
xunit_console="${nuget_dir}"/xunit.runner.console/"${xunit_console_version}"/tools/${target_framework}/xunit.console.dll
elif [[ "${runtime}" == "mono" ]]; then
file_list=(
- "${unittest_dir}/CSharpCompilerSymbolTest/net46/Roslyn.Compilers.CSharp.Symbol.UnitTests.dll"
- "${unittest_dir}/CSharpCompilerSyntaxTest/net46/Roslyn.Compilers.CSharp.Syntax.UnitTests.dll"
+ "${unittest_dir}/Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests/net46/Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests.dll"
+ "${unittest_dir}/Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests/net46/Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests.dll"
)
xunit_console="${nuget_dir}"/xunit.runner.console/"${xunit_console_version}"/tools/net452/xunit.console.exe
else
@@ -58,9 +58,9 @@ do
deps_json="${file_name%.*}".deps.json
runtimeconfig_json="${file_name%.*}".runtimeconfig.json
- # If the user specifies a test on the command line, only run that one
+ # If the user specifies a test assembly on the command line, only run that one
# "${3:-}" => take second arg, empty string if unset
- if [[ ("${3:-}" != "") && (! "${file_name}" =~ "${2:-}") ]]
+ if [[ ("${3:-}" != "") && (! "${file_name}" =~ "${3:-}") ]]
then
echo "Skipping ${file_name}"
continue
@@ -69,9 +69,10 @@ do
echo Running "${runtime} ${file_name[@]}"
if [[ "${runtime}" == "dotnet" ]]; then
runner="dotnet exec --depsfile ${deps_json} --runtimeconfig ${runtimeconfig_json}"
- if [[ "${file_name[@]}" == *'Roslyn.Compilers.CSharp.Emit.UnitTests.dll' ]] || [[ "${file_name[@]}" == *'Roslyn.Compilers.VisualBasic.Symbol.UnitTests.dll' ]] || [[ "${file_name[@]}" == *'Roslyn.Compilers.CSharp.Semantic.UnitTests.dll' ]] || [[ "${file_name[@]}" == *'Roslyn.Compilers.VisualBasic.Emit.UnitTests.dll' ]] || [[ "${file_name[@]}" == *'Roslyn.Compilers.VisualBasic.Semantic.UnitTests.dll' ]] || [[ "${file_name[@]}" == *'Roslyn.Compilers.VisualBasic.IOperation.UnitTests.dll' ]]
-
+ # Disable the VB Semantic tests while we investigate the core dump issue
+ # https://github.com/dotnet/roslyn/issues/29660
+ if [[ "${file_name[@]}" == *'Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests.dll' ]]
then
echo "Skipping ${file_name[@]}"
continue
@@ -79,7 +80,12 @@ do
elif [[ "${runtime}" == "mono" ]]; then
runner=mono
fi
- if ${runner} "${xunit_console}" "${file_name[@]}" -xml "${log_file}"
+
+ # https://github.com/dotnet/roslyn/issues/29380
+ # Pass additional arguments on to xunit_console directly.
+ # This allows you to (for example) run a single test method of a single test assembly, like so:
+ # ./build/scripts/tests.sh Debug dotnet Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests -method "*.Query_01"
+ if ${runner} "${xunit_console}" "${file_name[@]}" -xml "${log_file}" -parallel none "${@:4}"
then
echo "Assembly ${file_name[@]} passed"
else
diff --git a/build/scripts/vsts-robocopy.ps1 b/build/scripts/vsts-robocopy.ps1
new file mode 100644
index 0000000000000..60c35603329bf
--- /dev/null
+++ b/build/scripts/vsts-robocopy.ps1
@@ -0,0 +1,107 @@
+# See https://raw.githubusercontent.com/Microsoft/vsts-tasks/master/Tasks/PublishBuildArtifactsV1/Invoke-Robocopy.ps1
+
+[CmdletBinding()]
+param(
+ [Parameter(Mandatory = $true)]
+ [string]$Source,
+
+ [Parameter(Mandatory = $true)]
+ [string]$Target,
+
+ [Parameter(Mandatory = $true)]
+ [int]$ParallelCount,
+
+ [Parameter(Mandatory = $false)]
+ [string]$File)
+
+# This script translates the output from robocopy into UTF8. Node has limited
+# built-in support for encodings.
+#
+# Robocopy uses the system default code page. The system default code page varies
+# depending on the locale configuration. On an en-US box, the system default code
+# page is Windows-1252.
+#
+# Note, on a typical en-US box, testing with the '' character is a good way to
+# determine whether data is passed correctly between processes. This is because
+# the '' character has a different code point across each of the common encodings
+# on a typical en-US box, i.e.
+# 1) the default console-output code page (IBM437)
+# 2) the system default code page (i.e. CP_ACP) (Windows-1252)
+# 3) UTF8
+
+$ErrorActionPreference = 'Stop'
+
+# Redefine the wrapper over STDOUT to use UTF8. Node expects UTF8 by default.
+$stdout = [System.Console]::OpenStandardOutput()
+$utf8 = New-Object System.Text.UTF8Encoding($false) # do not emit BOM
+$writer = New-Object System.IO.StreamWriter($stdout, $utf8)
+[System.Console]::SetOut($writer)
+
+# All subsequent output must be written using [System.Console]::WriteLine(). In
+# PowerShell 4, Write-Host and Out-Default do not consider the updated stream writer.
+
+if (!$File) {
+ $File = "*";
+}
+
+# Print the ##command. The /MT parameter is only supported on 2008 R2 and higher.
+if ($ParallelCount -gt 1) {
+ [System.Console]::WriteLine("##[command]robocopy.exe /E /COPY:DA /NP /R:3 /MT:$ParallelCount `"$Source`" `"$Target`" `"$File`"")
+}
+else {
+ [System.Console]::WriteLine("##[command]robocopy.exe /E /COPY:DA /NP /R:3 `"$Source`" `"$Target`" `"$File`"")
+}
+
+# The $OutputEncoding variable instructs PowerShell how to interpret the output
+# from the external command.
+$OutputEncoding = [System.Text.Encoding]::Default
+
+# Usage :: ROBOCOPY source destination [file [file]...] [options]
+# source :: Source Directory (drive:\path or \\server\share\path).
+# destination :: Destination Dir (drive:\path or \\server\share\path).
+# file :: File(s) to copy (names/wildcards: default is "*.*").
+# /E :: copy subdirectories, including Empty ones.
+# /COPY:copyflag[s] :: what to COPY for files (default is /COPY:DAT).
+# (copyflags : D=Data, A=Attributes, T=Timestamps).
+# (S=Security=NTFS ACLs, O=Owner info, U=aUditing info).
+# /NP :: No Progress - don't display percentage copied.
+# /MT[:n] :: Do multi-threaded copies with n threads (default 8).
+# n must be at least 1 and not greater than 128.
+# This option is incompatible with the /IPG and /EFSRAW options.
+# Redirect output using /LOG option for better performance.
+# /R:n :: number of Retries on failed copies: default 1 million.
+#
+# Note, the output from robocopy needs to be iterated over. Otherwise PowerShell.exe
+# will launch the external command in such a way that it inherits the streams.
+#
+# Note, the /MT parameter is only supported on 2008 R2 and higher.
+if ($ParallelCount -gt 1) {
+ & robocopy.exe /E /COPY:DA /NP /R:3 /MT:$ParallelCount $Source $Target $File 2>&1 |
+ ForEach-Object {
+ if ($_ -is [System.Management.Automation.ErrorRecord]) {
+ [System.Console]::WriteLine($_.Exception.Message)
+ }
+ else {
+ [System.Console]::WriteLine($_)
+ }
+ }
+}
+else {
+ & robocopy.exe /E /COPY:DA /NP /R:3 $Source $Target $File 2>&1 |
+ ForEach-Object {
+ if ($_ -is [System.Management.Automation.ErrorRecord]) {
+ [System.Console]::WriteLine($_.Exception.Message)
+ }
+ else {
+ [System.Console]::WriteLine($_)
+ }
+ }
+}
+
+[System.Console]::WriteLine("##[debug]robocopy exit code '$LASTEXITCODE'")
+[System.Console]::Out.Flush()
+if ($LASTEXITCODE -ge 8) {
+ exit $LASTEXITCODE
+}
+
+exit 0
\ No newline at end of file
diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md
index b96cb4d3cea00..78065943078f8 100644
--- a/docs/Language Feature Status.md
+++ b/docs/Language Feature Status.md
@@ -11,23 +11,32 @@ efforts behind them.
| Feature | Branch | State | Developers | Reviewer | LDM Champ |
| ------- | ------ | ----- | ---------- | -------- | --------- |
| [Default Interface Methods](https://github.com/dotnet/csharplang/blob/master/proposals/default-interface-methods.md) | [defaultInterfaceImplementation](https://github.com/dotnet/roslyn/tree/features/DefaultInterfaceImplementation) | Prototype | [AlekseyTs](https://github.com/AlekseyTs) | [gafter](https://github.com/gafter) | [gafter](https://github.com/gafter) |
-| [Nullable reference type](https://github.com/dotnet/csharplang/blob/master/proposals/nullable-reference-types.md) | [NullableReferenceTypes](https://github.com/dotnet/roslyn/tree/features/NullableReferenceTypes) | Prototype | [cston](https://github.com/cston), [AlekseyTs](https://github.com/AlekseyTs) | [333fred](https://github.com/333fred) | [mattwar](https://github.com/mattwar) |
+| [Nullable reference type](https://github.com/dotnet/csharplang/blob/master/proposals/nullable-reference-types.md) | [NullableReferenceTypes](https://github.com/dotnet/roslyn/tree/features/NullableReferenceTypes) | Prototype | [cston](https://github.com/cston), [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs), [333fred](https://github.com/333fred) | [mattwar](https://github.com/mattwar) |
| [Recursive patterns](https://github.com/dotnet/csharplang/blob/master/proposals/patterns.md) | [recursive-patterns](https://github.com/dotnet/roslyn/tree/features/recursive-patterns) | Prototype | [gafter](https://github.com/gafter) | [agocke](https://github.com/agocke), [cston](https://github.com/cston) | [gafter](https://github.com/gafter) |
-| [Async streams](https://github.com/dotnet/csharplang/blob/master/proposals/async-streams.md) | [async-streams](https://github.com/dotnet/roslyn/tree/features/async-streams) | In Progress | [jcouv](https://github.com/jcouv) | [OmarTawfik](https://github.com/OmarTawfik) | [stephentoub](https://github.com/stephentoub) |
+| [Async streams](https://github.com/dotnet/csharplang/blob/master/proposals/async-streams.md) | [async-streams](https://github.com/dotnet/roslyn/tree/features/async-streams) | In Progress | [jcouv](https://github.com/jcouv) | [agocke](https://github.com/agocke) | [stephentoub](https://github.com/stephentoub) |
| [Caller expression attribute](https://github.com/dotnet/csharplang/issues/287) | [caller-expression](https://github.com/dotnet/roslyn/tree/features/caller-expression) | Prototype | [alrz](https://github.com/alrz) | [jcouv](https://github.com/jcouv) | [jcouv](https://github.com/jcouv) |
-| [Target-typed new](https://github.com/dotnet/csharplang/issues/100) | [target-typed-new](https://github.com/dotnet/roslyn/tree/features/target-typed-new) | Prototype | [alrz](https://github.com/alrz) | TBD | [jcouv](https://github.com/jcouv) |
-| [Pattern-based using](https://github.com/dotnet/csharplang/issues/1623) | [enhanced-using](https://github.com/dotnet/roslyn/tree/features/enhanced-using) | Prototype | [fayrose](https://github.com/fayrose) | [agocke](https://github.com/agocke) | [jaredpar](https://github.com/jaredpar) |
-| [Generic attributes](https://github.com/dotnet/csharplang/issues/124) | [generic-attributes](https://github.com/dotnet/roslyn/tree/features/generic-attributes) | In Progress | [AviAvni](https://github.com/AviAvni) | TBD | [mattwar](https://github.com/mattwar) |
-| [Ranges](https://github.com/dotnet/roslyn/blob/features/range/docs/features/range.md) | [range](https://github.com/dotnet/roslyn/tree/features/range) | In Progress | [OmarTawfik](https://github.com/OmarTawfik) | [vsadov](https://github.com/vsadov) | [jaredpar](https://github.com/jaredpar) |
-| [Default in deconstruction](https://github.com/dotnet/roslyn/pull/25562) | [decon-default](https://github.com/dotnet/roslyn/tree/features/decon-default) | Implemented | [jcouv](https://github.com/jcouv) | | [jcouv](https://github.com/jcouv) |
-| [Relax ordering of `ref` and `partial` modifiers](https://github.com/dotnet/csharplang/issues/946) | [ref-partial](https://github.com/dotnet/roslyn/tree/features/ref-partial) | In Progress | [alrz](https://github.com/alrz) | | [jcouv](https://github.com/jcouv) |
-| [Null Coalescing Assignment](https://github.com/dotnet/csharplang/issues/34) | [null-operator-enhancements](https://github.com/dotnet/roslyn/tree/features/null-operator-enhancements) | In Progress | [333fred](https://github.com/333fred) | TBD | [gafter](https://github.com/gafter)
+| [Target-typed new](https://github.com/dotnet/csharplang/issues/100) | [target-typed-new](https://github.com/dotnet/roslyn/tree/features/target-typed-new) | Prototype | [alrz](https://github.com/alrz) | [jcouv](https://github.com/jcouv) | [jcouv](https://github.com/jcouv) |
+| [Pattern-based using](https://github.com/dotnet/csharplang/issues/1623) | [enhanced-using](https://github.com/dotnet/roslyn/tree/features/enhanced-using) | Prototype | [chsienki](https://github.com/chsienki) | [agocke](https://github.com/agocke) | [jaredpar](https://github.com/jaredpar) |
+| [Generic attributes](https://github.com/dotnet/csharplang/issues/124) | [generic-attributes](https://github.com/dotnet/roslyn/tree/features/generic-attributes) | In Progress | [AviAvni](https://github.com/AviAvni) | [agocke](https://github.com/agocke) | [mattwar](https://github.com/mattwar) |
+| [Ranges](https://github.com/dotnet/roslyn/blob/features/range/docs/features/range.md) | [range](https://github.com/dotnet/roslyn/tree/features/range) | In Progress | [agocke](https://github.com/agocke) | [cston](https://github.com/cston) | [jaredpar](https://github.com/jaredpar) |
+| [Default in deconstruction](https://github.com/dotnet/roslyn/pull/25562) | [decon-default](https://github.com/dotnet/roslyn/tree/features/decon-default) | Implemented | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
+| [Relax ordering of `ref` and `partial` modifiers](https://github.com/dotnet/csharplang/issues/946) | [ref-partial](https://github.com/dotnet/roslyn/tree/features/ref-partial) | In Progress | [alrz](https://github.com/alrz) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
+| [Null-coalescing Assignment](https://github.com/dotnet/csharplang/issues/34) | master | Implemented | [333fred](https://github.com/333fred) | [cston](https://github.com/cston) | [gafter](https://github.com/gafter)
+| [Alternative interpolated verbatim strings](https://github.com/dotnet/csharplang/issues/1630) | master | Implemented | [jcouv](https://github.com/jcouv) | [cston](https://github.com/cston) | [jcouv](https://github.com/jcouv)
+| [stackalloc in nested contexts](https://github.com/dotnet/csharplang/issues/1412) | [nested-stackalloc](https://github.com/dotnet/roslyn/tree/features/nested-stackalloc) | In Progress | [gafter](https://github.com/gafter) | - | [gafter](https://github.com/gafter)
+
+# VB 16.0
+
+| Feature | Branch | State | Developers | Reviewer | LDM Champ |
+| ------- | ------ | ----- | ---------- | -------- | --------- |
+| [Line continuation comments](https://github.com/dotnet/vblang/issues/65) | [continuation-comments](https://github.com/dotnet/roslyn/tree/features/continuation-comments) | Prototype | [paul1956](https://github.com/paul1956) | [AlekseyTs](https://github.com/AlekseyTs) | [gafter](https://github.com/gafter) |
+| [Relax null coalesing operator requirements](https://github.com/dotnet/vblang/issues/339) | [null-operator-enhancements](https://github.com/dotnet/roslyn/tree/features/null-operator-enhancements) | In Progress | [333fred](https://github.com/333fred) | [cston](https://github.com/cston) | [gafter](https://github.com/gafter) |
# C# 7.3
| Feature | Branch | State | Developers | Reviewer | LDM Champ |
| ------- | ------ | ----- | ---------- | -------- | --------- |
-| [blittable](https://github.com/dotnet/csharplang/pull/206) | None | Merged | None | | [jaredpar](https://github.com/jaredpar) |
+| [blittable](https://github.com/dotnet/csharplang/pull/206) | None | Merged | None | - | [jaredpar](https://github.com/jaredpar) |
| [Support == and != for tuples](https://github.com/dotnet/csharplang/issues/190) | [tuple-equality](https://github.com/dotnet/roslyn/tree/features/tuple-equality) | Merged | [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs) | [jcouv](https://github.com/jcouv) |
| strongname | master | Merged | [tyoverby](https://github.com/tyoverby) | [agocke](https://github.com/agocke) | [jaredpar](https://github.com/jaredpar) |
| [Attribute on backing field](https://github.com/dotnet/csharplang/issues/42) | features/compiler | Merged | [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs) | [jcouv](https://github.com/jcouv) |
@@ -35,7 +44,7 @@ efforts behind them.
| Constraints | [constraints](https://github.com/dotnet/roslyn/tree/features/constraints) | Merged | [OmarTawfik](https://github.com/OmarTawfik) | [vsadov](https://github.com/vsadov) | [jarepdar](https://github.com/jaredpar) |
| [Stackalloc initializers](https://github.com/dotnet/csharplang/issues/1286) | [stackalloc-init](https://github.com/dotnet/roslyn/tree/features/stackalloc-init) | Merged | [alrz](https://github.com/alrz) | [vsadov](https://github.com/vsadov) | [jcouv](https://github.com/jcouv) |
| [Custom fixed](https://github.com/dotnet/csharplang/issues/1314) | [custom-fixed](https://github.com/dotnet/roslyn/tree/features/custom-fixed) | Merged | [vsadov](https://github.com/vsadov) | [jcouv](https://github.com/jcouv) | [jarepdar](https://github.com/jaredpar) |
-| [Indexing movable fixed buffers](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.3/indexing-movable-fixed-fields.md) | | Merged | [vsadov](https://github.com/vsadov) | [jcouv](https://github.com/jcouv) | [jarepdar](https://github.com/jaredpar) |
+| [Indexing movable fixed buffers](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.3/indexing-movable-fixed-fields.md) | - | Merged | [vsadov](https://github.com/vsadov) | [jcouv](https://github.com/jcouv) | [jarepdar](https://github.com/jaredpar) |
| [Improved overload candidates](https://github.com/dotnet/csharplang/issues/98) | features/compiler | Merged | [gafter](https://github.com/gafter) | [cston](https://github.com/cston) | [mattwar](https://github.com/mattwar) |
| [Expression variables](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.3/expression-variables-in-initializers.md) | [features/ExpressionVariables](https://github.com/dotnet/roslyn/tree/features/ExpressionVariables) | Merged | [AlekseyTs](https://github.com/AlekseyTs) | [gafter](https://github.com/gafter) | [gafter](https://github.com/gafter) |
@@ -43,8 +52,8 @@ efforts behind them.
| Feature | Branch | State | Developers | Reviewer | LDM Champ |
| ------- | ------ | ----- | ---------- | -------- | --------- |
-| [`ref` and `this` ordering in ref extension](https://github.com/dotnet/roslyn/pull/23643) | | Merged | [alrz](https://github.com/alrz) | | |
-| [Tiebreaker for by-val and `in` overloads](https://github.com/dotnet/roslyn/pull/23122) | master | Merged | [OmarTawfik](https://github.com/OmarTawfik) | | |
+| [`ref` and `this` ordering in ref extension](https://github.com/dotnet/roslyn/pull/23643) | - | Merged | [alrz](https://github.com/alrz) | - | - |
+| [Tiebreaker for by-val and `in` overloads](https://github.com/dotnet/roslyn/pull/23122) | master | Merged | [OmarTawfik](https://github.com/OmarTawfik) | - | - |
# C# 7.2
@@ -55,7 +64,7 @@ efforts behind them.
| [non-trailing named arguments](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.2/non-trailing-named-arguments.md) | master | Merged | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) |
| [private protected](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.2/private-protected.md) | master | Merged | [gafter](https://github.com/gafter) | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) |
| [conditional ref operator](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.2/conditional-ref.md) | master | Merged | [vsadov](https://github.com/vsadov) | [cston](https://github.com/cston) | [jaredpar](https://github.com/jaredpar) |
-| [Digit separator after base specifier](https://github.com/dotnet/roslyn/pull/20449) | master | Merged | [alrz](https://github.com/alrz) | | [gafter](https://github.com/gafter) |
+| [Digit separator after base specifier](https://github.com/dotnet/roslyn/pull/20449) | master | Merged | [alrz](https://github.com/alrz) | - | [gafter](https://github.com/gafter) |
# C# 7.1
diff --git a/docs/analyzers/Analyzer Actions Semantics.md b/docs/analyzers/Analyzer Actions Semantics.md
index 8ad80db7f4a7b..e4789e3621faa 100644
--- a/docs/analyzers/Analyzer Actions Semantics.md
+++ b/docs/analyzers/Analyzer Actions Semantics.md
@@ -1,9 +1,11 @@
-**Definitions:**
+**Definitions:**
- **Session:** For batch compilation, a single compilation. For a hosted environment, an arbitrary duration potentially encompassing many compilations. In particular, for VS, a session shares the lifetime and scope of an analyzer reference, which may correspond to a loaded project, a loaded solution, or the VS process.
- **Analyzer:** An instance of a type derived from `DiagnosticAnalyzer`.
- **Action:** A method instance registered via a Register\*\*\*Action method of an instance of a \*\*\*Context class, to be automatically applied as appropriate. Every action is associated with an analyzer and has a kind (which is one of compilation start, syntax tree, symbol, code block start, syntax node, code block, code block end, semantic model, compilation, compilation end).
- - **Code block:** A single unit of executable code, e.g. a method body, parameter default value, field initializer, etc.)
+ - **Operation block:** A single unit of executable code containing operation nodes, e.g. a method body, parameter default value, field initializer, etc. Operation blocks are primarily used for semantic analysis of executable code using the `IOperation` APIs.
+ - **Code block:** A single unit of executable code containing syntax nodes, e.g. a method body, parameter default value, field initializer, etc. Code blocks are primarily used for syntax and/or semantic analysis of executable code using the language specific Syntax APIs. However, it is recommended that analyzers use Operation block and `IOperation` API for semantic analysis of executable code for improved performance and simpler, language-agnostic implementation.
+ - **Symbol members:** List of zero or member symbols for a given `ISymbol`. For a namespace or type symbol, these are the members returned by [INamespaceOrTypeSymbol.GetMembers](http://source.roslyn.io/#Microsoft.CodeAnalysis/Symbols/INamespaceOrTypeSymbol.cs,23) API, which include nested symbols. Method, field, event and property symbols have no member symbols.
**Axioms:**
- Two different analyzers are assumed not to share state. No actions of a single analyzer execute concurrently, unless they explicitly configure concurrent execution in the `DiagnosticAnalyzer.Initialize` method by invoking `AnalysisContext.EnableConcurrentExecution`. Actions of different analyzers may execute concurrently. (This is likely to be refined as we develop more sophisticated concurrency strategies, but it will remain true that actions will generally not require locks to avoid races.)
@@ -16,11 +18,18 @@ The `DiagnosticAnalyzer.Initialize` method of an analyzer is invoked before any
The following rules related to action invocation apply per compilation or per any environmental change that invalidates prior analysis (e.g. changes to analyzer options or changes to non-compiled documents used by analyzers). For purposes of this specification, such environmental changes act as if they create a new compilation.
-There are no ordering constraints for the invocations of any actions, except those introduced by compilation start, compilation end, code bock start, and code block end actions. Invocations of actions of one kind may be interleaved with invocations of actions of another kind. A given host environment might appear to provide a predictable order—for example, invoking syntax tree actions before semantic model actions, or symbol actions before code block actions, but depending on such an ordering is not safe.
+There are no ordering constraints for the invocations of any actions, except those introduced by start and end actions (compilation start, compilation end, symbol start, symbol end, operation block start, operation block end, code bock start, and code block end actions). Invocations of actions of one kind may be interleaved with invocations of actions of another kind. A given host environment might appear to provide a predictable order—for example, invoking syntax tree actions before semantic model actions, or symbol actions before code block actions, but depending on such an ordering is not safe.
- A compilation start action is invoked once, before any of the analyzer’s other kinds of actions are invoked. Actions registered by a compilation start action apply to that compilation only.
- A syntax tree action is invoked once per source document. A syntax tree action can be expected to be invoked as early as possible after a document is parsed, but this is not guaranteed.
- A symbol action is invoked once per complete semantic processing of a declaration of a type or type member, provided that symbol has a kind matching one of the kinds supplied when the action was registered.
+ - A symbol start action is invoked exactly once for every symbol of registered `SymbolKind`, before any of the analyzer’s other kinds of actions are invoked on the symbol or the symbol's members. A symbol start action can register following actions:
+ - Actions for syntax and operation nodes within the symbol and its members: Operation action, operation block action, operation block start action, syntax node action, code block action and code block start action.
+ - Symbol end action for the symbol, after all other applicable actions of an analyzer have been invoked on the symbol and its members.
+ - An operation block start action is invoked once per operation block, before any operation node actions applicable to nodes within the block. Actions registered by a operation block start action apply to that operation block only.
+ - An operation action is invoked once per operation node, provided that the operation node has a kind matching one of the kinds supplied when the action was registered.
+ - An operation block action is invoked once per operation block.
+ - An operation block end action is invoked once per operation block, after invoking any operation node actions applicable to nodes within the block and any operation block actions for the block.
- A code block start action is invoked once per code block, before any syntax node actions applicable to nodes within the block. Actions registered by a code block start action apply to that code block only.
- A syntax node action is invoked once per syntax node, provided that the syntax node has a kind matching one of the kinds supplied when the action was registered.
- A code block action is invoked once per code block.
@@ -31,6 +40,8 @@ There are no ordering constraints for the invocations of any actions, except tho
Summarizing the ordering rules:
- For a given compilation, compilation start actions run first and compilation end actions run last.
+- For a given symbol, symbol start actions run before operation/syntax/symbol actions on a symbol and its members, and these operation/syntax/symbol actions run before the symbol end actions.
+- For a given operation block, operation block start actions run before operation node actions, and operation node actions run before the operation block end actions.
- For a given code block, code block start actions run before syntax node actions, and syntax node actions run before code block end actions.
- Otherwise, there are no ordering guarantees for action invocation.
diff --git a/docs/compilers/CSharp/Compiler Breaking Changes - VS2019.md b/docs/compilers/CSharp/Compiler Breaking Changes - VS2019.md
new file mode 100644
index 0000000000000..de5124878f1f9
--- /dev/null
+++ b/docs/compilers/CSharp/Compiler Breaking Changes - VS2019.md
@@ -0,0 +1,31 @@
+**This document lists known breaking changes in Roslyn 3.0 (Visual Studio 2019) from Roslyn 2.* (Visual Studio 2017)
+
+*Breaks are formatted with a monotonically increasing numbered list to allow them to referenced via shorthand (i.e., "known break #1").
+Each entry should include a short description of the break, followed by either a link to the issue describing the full details of the break or the full details of the break inline.*
+
+1. https://github.com/dotnet/roslyn/issues/27800 C# will now preserve left-to-right evaluation for compound assignment addition/subtraction expressions where the left-hand side is dynamic. In this example code:
+ ``` C#
+ class DynamicTest
+ {
+ public int Property { get; set; }
+ static dynamic GetDynamic() => return new DynamicTest();
+ static int GetInt() => 1;
+ public static void Main() => GetDynamic().Property += GetInt();
+ }
+ ```
+ - Previous versions of Roslyn would have evaluated this as:
+ 1. GetInt()
+ 2. GetDynamic()
+ 3. get_Property
+ 4. set_Property
+ - We now evaluate it as
+ 1. GetDynamic()
+ 2. get_Property
+ 3. GetInt()
+ 4. set_Property
+
+2. Previously, we allowed adding a module with `Microsoft.CodeAnalysis.EmbeddedAttribute` or `System.Runtime.CompilerServices.NonNullTypesAttribute` types declared in it.
+ In Visual Studio 2019, this produces a collision error with the injected declarations of those types.
+
+3. Previously, you could refer to a `System.Runtime.CompilerServices.NonNullTypesAttribute` type declared in a referenced assembly.
+ In Visual Studio 2019, the type from assembly is ignored in favor of the injected declaration of that type.
diff --git a/docs/compilers/CSharp/Overload Resolution.md b/docs/compilers/CSharp/Overload Resolution.md
index 7ad32fad31e79..6a4ff9f5a7afa 100644
--- a/docs/compilers/CSharp/Overload Resolution.md
+++ b/docs/compilers/CSharp/Overload Resolution.md
@@ -95,4 +95,17 @@ var x = new Test(10);
Old compiler calls the second overload (```Test(int a, params List[] p)```)
-See #4458 for more details, and #4761 for the implementation and tests that enable Roslyn to compile this code.
\ No newline at end of file
+See https://github.com/dotnet/roslyn/issues/4458 for more details, and https://github.com/dotnet/roslyn/issues/4761 for the implementation and tests that enable Roslyn to compile this code.
+
+### Compiler won't lift asymmetric `operator==` and `operator!=`
+
+The C# compiler (all versions) won’t lift user-defined equality operators
+
+``` c#
+public static bool operator ==(Type1 x, Type2 y)
+public static bool operator !=(Type1 x, Type2 y)
+```
+
+unless `Type1` and `Type2` are identical types. The spec requires all user-defined equality operators defined on value types to also be considered in lifted form, so this is technically a spec violation. We believe that fixing this longstanding behavior might break some programs, so we do not expect to change it.
+
+See https://github.com/dotnet/roslyn/issues/13686 for more details.
diff --git a/docs/compilers/Visual Basic/Compiler Breaking Changes - VS2015.md b/docs/compilers/Visual Basic/Compiler Breaking Changes - VS2015.md
index e465ceb79a281..96dc691e66a5b 100644
--- a/docs/compilers/Visual Basic/Compiler Breaking Changes - VS2015.md
+++ b/docs/compilers/Visual Basic/Compiler Breaking Changes - VS2015.md
@@ -107,4 +107,3 @@ This list tracks known cases where the Roslyn compiler intentionally deviates fr
According to @AlekseyTs , "Dev10 considers some expressions as invalid in context of a constant expression, even if those expressions are not going to be evaluated. Lambdas, Query Expressions, and probably Object Initializers fall into that category."
These rules are being relaxed in Roslyn. A constant expression will be allowed of the form expr.ID where ID is a constant member of the type of the expression. The expression will not be evaluated and a warning will be issued. There are no restrictions on the form of expr, other than that it must be syntactically and semantically valid.
-
diff --git a/docs/compilers/Visual Basic/Overflow In Embedded Runtime.md b/docs/compilers/Visual Basic/Overflow In Embedded Runtime.md
new file mode 100644
index 0000000000000..c55bab1295af7
--- /dev/null
+++ b/docs/compilers/Visual Basic/Overflow In Embedded Runtime.md
@@ -0,0 +1,12 @@
+### VB Embedded Runtime inherits overflow checking from the compilation
+
+See https://github.com/dotnet/roslyn/issues/6941. Some VB runtime methods are specified to throw an `OverflowException` when a converted value overflows the target type. When compiling a VB project with the runtime embedded (`/vbruntime*`), the compiler includes the necessary VB runtime helpers into the assembly that is produced. These runtime helpers inherit the overflow checking behavior of the VB.NET project that they are embedded into. As a result, if you both embed the runtime and have overflow checking disabled (`/removeintchecks+`), you will not get the specified exceptions from the runtime helpers. Although technically it is a bug, it has long been the behavior of VB.Net and we have found that customers would be broken by having it fixed, so we do not expect to change this behavior.
+
+``` vb
+Sub Main()
+ Dim s As SByte = -128
+ Dim o As Object = s
+ Dim b = CByte(o) ' Should throw OverflowException but does not if you compile with /vbruntime* /removeintchecks+
+ Console.WriteLine(b)
+End Sub
+```
diff --git a/docs/contributing/Building, Debugging, and Testing on Unix.md b/docs/contributing/Building, Debugging, and Testing on Unix.md
index 55f943dad3bbc..9899d5fba62e2 100644
--- a/docs/contributing/Building, Debugging, and Testing on Unix.md
+++ b/docs/contributing/Building, Debugging, and Testing on Unix.md
@@ -1,14 +1,87 @@
-# Getting the Code
+# Building, Debugging and Testing on Unix
+This guide is meant to help developers setup an environment for debugging / contributing to Roslyn from Linux.
+Particularly for developers who aren't experienced with .NET Core development on Linux.
+## Working with the code
1. Install the [.NET Core SDK](https://www.microsoft.com/net/download/core)
-1. Clone https://github.com/dotnet/roslyn
-1. Run `dotnet restore CrossPlatform.sln`
-1. Run `dotnet build CrossPlatform.sln`
+1. Clone git@github.com:dotnet/roslyn.git
+1. Run `./build.sh --restore`
+1. Run `./build.sh --build`
-# Running Tests
+## Running Tests
+The unit tests can be executed by running `./build.sh --test`
-After building run `build\scrits\test.sh` in order to run the unit tests.
+## GitHub
+The best way to clone and push is to use SSH. On Windows you typically use HTTPS and this is not directly compatible
+with two factor authentication (requires a PAT). The SSH setup is much simpler and GitHub has a great HOWTO for
+getting this setup.
-# Contributing
+https://help.github.com/articles/connecting-to-github-with-ssh/
-Please see [Contributing Code](https://github.com/dotnet/roslyn/blob/master/CONTRIBUTING.md) for details on contributing changes back to the code.
+## Debugging test failures
+The best way to debug is using lldb with the SOS plugin. This is the same SOS as used in WinDbg and if you're familiar
+with it then lldb debugging will be pretty straight forward.
+
+Here are the CoreCLR guidelines for Linux debugging:
+
+- https://github.com/dotnet/coreclr/blob/master/Documentation/botr/xplat-minidump-generation.md
+- https://github.com/dotnet/coreclr/blob/master/Documentation/building/debugging-instructions.md#debugging-core-dumps-with-lldb.
+
+Corrections:
+- LLDB and createdump must be run as root
+- `dotnet tool install -g dotnet-symbol` must be run from `$HOME`
+
+Furthermore the version of SOS that comes with the runtime will likely not work with the lldb you have. In order to
+use SOS you will need to build it by hand
+
+1. Clone git@github.com:dotnet/diagnostics.git
+1. Run `./build.sh`
+
+This will produce libsosplugin.so that can be used in lldb. Once it's built you can start lldb with the following
+command line (replace `/home/jaredpar` as appropriate):
+
+``` bash
+> sudo lldb -o "plugin load /home/jaredpar/code/diagnostics/artifacts/Debug/bin/Linux.x64/libsosplugin.so"
+/home/jaredpar/code/roslyn/Binaries/Tools/dotnet/dotnet
+```
+
+From there you should be able to attach to running processes or load up coredumps.
+
+## Ubuntu 18.04
+The recommended OS for developing Roslyn is Ubuntu 18.04. This guide was written using Ubuntu 18.04 but should be
+applicable to most Linux enviroments. Ubuntu 18.04 was chosen here due to it's support for enhanced VMs in Hyper-V.
+This makes it easier to use from a Windows machine.
+
+### Hyper-V
+When using Hyper-V to develop you will want to enable enhanced mode. This allows for the VM to be full screen, have
+clipboard access and support additional devices. Ubuntu 18.04 is the first Linux OS supported in this mode. The
+mileage with other distros may vary.
+
+Enhanced mode support is still fairly new and does require a few manual steps. They are all covered in this
+blog post:
+
+https://blogs.technet.microsoft.com/virtualization/2018/02/28/sneak-peek-taking-a-spin-with-enhanced-linux-vms/
+
+Following the steps on that blog post will get you to a point where you can the features you are looking for. There are
+ a couple of deviations from the instructions there:
+
+- There is no longer a config-user.sh script
+- cd into `ubuntu/18.04` instead of `ubuntu/16.04`
+
+### Source Link
+Many of the repositories that need to be built use source link and it crashes on Ubuntu 18.04 due to dependency changes.
+To disable source link add the following to the `Directory.Build.props` file in the root of the repository.
+
+``` xml
+false
+false
+false
+```
+### Prerequisites
+
+Make sure to install the following via `apt install`
+
+- clang
+- lldb
+- cmake
+- xrdp
diff --git a/docs/contributing/Building, Debugging, and Testing on Windows.md b/docs/contributing/Building, Debugging, and Testing on Windows.md
index 2ce5becd3a19c..cf84fb0987c98 100644
--- a/docs/contributing/Building, Debugging, and Testing on Windows.md
+++ b/docs/contributing/Building, Debugging, and Testing on Windows.md
@@ -23,7 +23,7 @@ If a stack trace is displayed on .NET Framework older than 4.7.2 (e.g. by xUnit
1. [Visual Studio 2017 Version 15.7](https://www.visualstudio.com/vs/preview/)
- Ensure C#, VB, MSBuild, .NET Core and Visual Studio Extensibility are included in the selected work loads
- Ensure Visual Studio is on Version "15.7" or greater
-1. [.NET Core SDK 2.1.300](https://www.microsoft.com/net/download/core) (the current previews are: [Windows x64 installer](https://dotnetcli.blob.core.windows.net/dotnet/Sdk/2.1.300-rtm-008866/dotnet-sdk-2.1.300-rtm-008866-win-x64.exe), [Windows x86 installer](https://dotnetcli.blob.core.windows.net/dotnet/Sdk/2.1.300-rtm-008866/dotnet-sdk-2.1.300-rtm-008866-win-x86.exe))
+1. [.NET Core SDK 2.1.401](https://www.microsoft.com/net/download/core) (the installers are: [Windows x64 installer](https://dotnetcli.blob.core.windows.net/dotnet/Sdk/2.1.401/dotnet-sdk-2.1.401-win-x64.exe), [Windows x86 installer](https://dotnetcli.blob.core.windows.net/dotnet/Sdk/2.1.401/dotnet-sdk-2.1.401-win-x86.exe))
1. [PowerShell 3.0 or newer](https://docs.microsoft.com/en-us/powershell/scripting/setup/installing-windows-powershell). If you are on Windows 10, you are fine; you'll only need to upgrade if you're on Windows 7. The download link is under the "upgrading existing Windows PowerShell" heading.
1. Run Restore.cmd
1. Open Roslyn.sln
diff --git a/docs/contributing/Compiler Test Plan.md b/docs/contributing/Compiler Test Plan.md
index 4d9380640d198..47cec40367537 100644
--- a/docs/contributing/Compiler Test Plan.md
+++ b/docs/contributing/Compiler Test Plan.md
@@ -93,6 +93,7 @@ This document provides guidance for thinking about language interactions and tes
- COM interop
- modopt and modreq
- ref assemblies
+- extern alias
- telemetry
# Testing in interaction with other components
@@ -248,6 +249,7 @@ x >>= y
x &= y
x ^= y
x |= y
+x ??= y
x => { }
sizeof( )
*x
diff --git a/docs/designNotes/2015-01-14 VB Design Meeting.md b/docs/designNotes/2015-01-14 VB Design Meeting.md
deleted file mode 100644
index 148a4dd8145cf..0000000000000
--- a/docs/designNotes/2015-01-14 VB Design Meeting.md
+++ /dev/null
@@ -1,198 +0,0 @@
-VB Design Meeting 2015-01-14
-============================
-
-# Overload Resolution for String Interpolation
-
-Discussion thread for these notes can be found at https://github.com/dotnet/roslyn/issues/46.
-
-# Summary
-
-* Exactly like C#, we will consider an interpolated string to be like a string in most cases such as overload resolution and searches for user-defined/intrinsic conversion. This implies that what the IDE intellisense shows after $"hello".| should be the same as that for regular strings.
-
-* We wrote out some gnarly type-inference test cases for overload resolution and array literals with interpolated strings, and explained the expected output.
-
-* We would like both C# and VB to give more actionable error messages if they end up binding to a factory Create method whose return type isn't right
-
-* We reaffirmed intended behavior for full-width characters in interpolated strings
-
-# Overload resolution for string interpolation
-
-We want interpolated strings to be easily used as both String and FormattableString:
-```vb
- Dim x As String = $"hello {p}" ' works fine
- Dim x As FormattableString = $"hello {p}" ' works fine
- Dim x = $"hello {p}" ' works fine, and infers x As String
-```
-
-The question is about overload resolution... Which candidate should it prefer? Or should it be an ambiguity error?
-```vb
- Sub f(x As FormattableString) : End Sub
- Sub f(x As String) : End Sub
-
- f($"hello {p}") ' ... which does it pick?
-```
-
-One important principle is that if there's an existing API `Sub f(x As String)` then consumers MUST be able to call it with `f($"hello {p}")`.
-
-
-Another question is: if there's a language intrinsic conversion from string, does that conversion also apply to interpolated strings? e.g.
-```vb
- Dim x As Char() = "hello people" ' works fine
- Dim x As Char() = $"hello {x}" ' should this also work?
-```
-And separately, if there's a user-defined intrinsic conversion from string, does that conversion also apply to interpolated strings?
-
-(In C# the intention is that both should work. Have to verify that we've covered that in unit tests.)
-
-
-
-## API DESIGN Proposal 1a
-"Some library APIs really want consumers to use FormattableString because it is safer or faster. The API that takes string and the API that takes FormattableString actually do different things and hence shouldn't be overloaded on the same name. Library authors will want to lead people to use interpolated strings, hence it should have a shorter name."
-```vb
- Sub ExecuteQueryUnsafe(s As String) ...
- Sub ExecuteQuery(s As FormattableString) ...
-
- Sql.ExecuteQueryUnsafe(GetRegValueEx(path))
- Sql.ExecuteQueryUnsafe("from p in people select p.Name")
- Sql.ExecuteQuery($"from p in {x} select p.Name")
-```
-
-Q. If they do different things, then wouldn't you want an ambiguity error here?
-
-
-## API DESIGN Proposal 1b
-"In other library APIs, strings and FormattableStrings are equally fine; overloads make sense; we should prefer string overload because it will be more efficient"
-```vb
- Sub WriteLine(s As String) ...
-
- Console.WriteLine("hello everyone")
- Console.WriteLine($"hello {fred}")
-```
-
-Q. Isn't it an *antipattern* for an API to have both String and FormattableString if they just do the same thing?
-
-A. Well, maybe, but it could be valid and useful to overload on both String and IFormattable. (Or an overload of both String and Object and then do a TryCast to IFormattable).
-
-
-## Proposal 2
-"I don't like Safe/Unsafe. How about these names? ..."
-```vb
- Sub ExecuteQuery(s As String) ...
- Sub ExecuteQuery(s As FormattableString) ...
-
- Sql.ExecuteQuery(GetRegValueEx(path))
- Sql.ExecuteQuery("from p in people select p.Name")
- Sql.ExecuteQueryWithFormat($"from p in {x} select p.Name")
-```
-
-
-## API DESIGN Proposal 3
-"Someone will start with ExecuteQuery, and when they change the argument to $ then they won't see or understand the differently-named method. So let's pick the FormattableString overload which is most likely to be safe."
-```vb
- Sub ExecuteQuery(s As String) ...
- Sub ExecuteQuery(s As FormattableString) ...
-
- Sql.ExecuteQuery("from p in people select p.Name") ' picks String overload
- Sql.ExecuteQuery(GetRegValueEx(path)) ' picks String overload
- Sql.ExecuteQuery($"from p in {x} select p.Name") ' picks FormattableString overload
-```
-
-Q. What about the following consequence? Imagine an API has existed whose behavior is to format its string in a particular culture
-```vb
- Sub f(x As IFormattable)
- f($"hello {p}")
-```
-And later on down the line someone adds a new overload that takes string
-```vb
- Sub f(x As String)
-```
-Then the user's call will change behavior upon recompilation.
-
-
-## RESOLUTION
-We generally believe that libraries will mostly be written with different API names for methods which do different things. Therefore overload resolution differences between FormattableString and String don't matter, so string might as well win. Therefore we should stick with the simple principle that an interpolated string *is* a string. End of story.
-
-Implication: in intellisense `$"hello".|` will show extension methods off String, but will *NOT* show extension methods off FormattableString.
-
-Implication: both intrinsic and user-defined conversions that apply to string will also apply to interpolated string
-
-Implication: overload resolution will prefer String over FormattableString candidates when given an interpolated string argument.
-
-Implication: type inference works as follows.
-```vb
-Sub f(Of T)(x As T)
-f($"hello {p}")
-' then it picks string. (it has *contributed* string as a candidate)
-
-Sub f(Of T)(x As T, y As T)
-f($"hello {p}", CType(Nothing, FormattableString))
-' Then it gets two candidates, "String" and "FormattableString"
-' In most of the language (other than array literals), it checks whether
-' the *type* of each argument can convert to the candidate type.
-' In this case it will give an error.
-```
-
-Implication: if you have an array literal that contains an interpolated string expression
-```vb
- Dim x = {$"hello", CType(Nothing, IFormattable)}
-```
-then this will pick "Object Assumed" in Option Strict Off, and give an error in Option Strict On. The reason is that there is no dominant type between the candidate types "String" and "IFormattable". (There's no widening/identity conversion from one to the other, and there is a narrowing conversion from each to the other).
-
-
-## About the factory method that interpolation strings use
-
-The language conversion rules bake in knowledge of `System.IFormattable` and `System.FormattableString` for their knowledge of widening conversions.
-
-The compiler emits a call to a factory method when there is an interpolated string in source code. The factory method looks like this. There might be a whole family of overloaded Create methods.
-```vb
-System.Runtime.CompilerServices.FormattableStringFactory
- Function Create(...) As ...
-```
-The compiler separates the interpolated-string into a format string and a comma-separated list of expressions for the holes which it classifies as values before generating a call to `Create(fmtstring, expr1, expr2, ...)`. It will rely on normal VB overload resolution to pick the best Create method. This leaves the implementors of the factory free to do lots of nice optimizations.
-
-The question is, what return type do we expect from the Create method?
-
-Option1: We could bake in the requirement that the factory method gives back a System.FormattableString, and this type must implement System.IFormattable, and do this as a pre-filter prior to doing overload resolution of the Create() overload family.
-
-Option2: Or we could merely invoke the method, and do a cast of the return type to IFormattable/FormattableString depends on what the user asked for. But then...
-* Do we give a warning if it has the [Obsolete] attribute?
-* Do we give a warning if it is narrowing?
-* What if it picks a Sub() ?
-
-Option3: Just do plain ordinary overload resolution, and if there were ANY errors or warnings, them emit them. In addition, if there were any errors (not just warnings that happened to be WarnAsError'd), then additionally report an error message at the same location "The factory is malformed". Precedent: we do this for queries. [Note: this message might appear or disappear if you change option strict on/off in your file].
-
-Option4: As with Option3 but enforcing it to use Option Strict On for its overload resolution and its conversion to IFormattable/FormattableString.
-
-RESOLUTION: Option3.
-
-
-
-Q. What about delegate relaxation level of $"hello" to FormattableString/IFormattable ?
-```vb
-Sub f(lambda as Func(Of FormattableString))
-Sub f(lambda as Func(Of String))
-f(Function() $"hello")
-```
-RESOLUTION: From the principle above, we'd like this to pick the String overload. The way to accomplish this is to classify the lambda conversion as DelegateRelaxationLevelReturnWidening.
-
-
-
-Q. What about full-width characters?
-e.g. does $"{{" give the non-full-width string "{" even if the two source characters had different widths?
-e.g. can you write $"{p}" where the open is wide and the close is normal width?
-e.g. there is no escape to put a full-width {, similar to how there's no escape to put a full-width " ?
-
-RESOLUTION: Yes that's all fine.
-
-
-
----
-
-These are the workitems left to do...
-
-C#: additionally report error message about bad factory
-C#: verify (add a test case) that user-defined and intrinsic conversions on string really are used for interpolated strings.
-VB: change array literal dominant type stuff
-VB: all the dominant type stuff
-VB: fix up delegate relaxation level to be widening (and write test for it)
-
diff --git a/docs/designNotes/2015-01-21 C# Design Meeting.md b/docs/designNotes/2015-01-21 C# Design Meeting.md
deleted file mode 100644
index 1c42d57686865..0000000000000
--- a/docs/designNotes/2015-01-21 C# Design Meeting.md
+++ /dev/null
@@ -1,434 +0,0 @@
-C# Design Meeting Notes for Jan 21, 2015
-========================================
-
-Discussion thread on these notes can be found at https://github.com/dotnet/roslyn/issues/98.
-
-Quotes of the day:
-
-> Live broadcast of design meetings: we could call it C#-SPAN
->
-> We've made it three hours without slippery slopes coming up!
-
-
-Agenda
-------
-
-This is the first design meeting for the version of C# coming after C# 6. We shall colloquially refer to it as C# 7. The meeting focused on setting the stage for the design process and homing in on major themes and features.
-
-1. Design process
-2. Themes
-3. Features
-
-See also [Language features currently under consideration by the language design group](https://github.com/dotnet/roslyn/issues?q=is%3Aopen+label%3A%22Area-Language+Design%22+label%3A%221+-+Planning%22+ "Language Features Under Consideration").
-
-1. Design process
-=================
-
-We have had great success sharing design notes publicly on CodePlex for the last year of C# 6 design. The ability of the community to see and respond to our thinking in real time has been much appreciated.
-
-This time we want to increase the openness further:
-
-- we involve the community from the beginning of the design cycle (as per these notes!)
-- in addition to design notes (now issues on GitHub) we will maintain feature proposals (as checked-in Markdown documents) to reflect the current design of the feature
-- we will consider publishing recordings of the design meetings themselves, or even live streaming
-- we will consider adding non-Microsoft members to the design team.
-
-Design team
------------
-
-The C# 7 design team currently consists of
-
-- [Anders Hejlsberg](https://github.com/ahejlsberg)
-- [Mads Torgersen](https://github.com/MadsTorgersen)
-- [Lucian Wischik](https://github.com/ljw1004)
-- [Matt Warren](https://github.com/mattwar)
-- [Neal Gafter](https://github.com/gafter)
-- [Anthony D. Green](https://github.com/AnthonyDGreen)
-- [Stephen Toub](https://github.com/stephentoub)
-- [Kevin Pilch-Bisson](https://github.com/Pilchie)
-- [Vance Morrison](https://github.com/vancem)
-- [Immo Landwerth](https://github.com/terrajobst)
-
-Anders, as the chief language architect, has ultimate say, should that ever become necessary. Mads, as the language PM for C#, pulls together the agenda, runs the meetings and takes the notes. (Oooh, the power!)
-
-To begin with, we meet 4 hours a week as we decide on the overall focus areas. There will not be a separate Visual Basic design meeting during this initial period, as many of the overall decisions are likely to apply to both and need to happen in concert.
-
-Feature ideas
--------------
-
-Anyone can put a feature idea up as an *issue* on GitHub. We'll keep an eye on those, and use them as input to language design.
-
-A way to gauge interest in a feature is to put it up on UserVoice, where there's a voting system. This is important, because the set of people who hang out in our GitHub repo are not necessarily representative of our developer base at large.
-
-Design notes
-------------
-
-Design notes are point-in-time documents, so we will put them up as *issues* on GitHub. For a period of time, folks can comment on them and the reactions will feed into subsequent meetings.
-
-Owners and proposals
---------------------
-
-If the design team decides to move on with a feature idea, we'll nominate an *owner* for it, typically among the design team members, who will drive the activities related to the design of that feature: gathering feedback, making progress between meetings, etc. Most importantly, the owner will be responsible for maintaining a *proposal* document that describes the current state of that feature, cross-linking with the design notes where it was discussed.
-
-Since the proposals will evolve over time, they should be documents in the repo, with history tracked. When the proposal is first put up, and if there are major revisions, we will probably put up an issue too, as a place to gather comments. There can also be pull requests to the proposals.
-
-We'll play with this process and find a balance.
-
-Other ways of increasing openness
----------------------------------
-
-We are very interested in other ideas, such as publishing recordings (or even live streaming?) of the design meeting themselves, and inviting non-Microsoft luminaries, e.g., from major players in the industry, onto the design team itself. We are certainly open to have "guests" (physical or virtual) when someone has insights that we want to leverage.
-
-However, these are things we can get to over time. We are not going to do them right out of the gate.
-
-Decisions
----------
-
-It's important to note that the C# design team is still in charge of the language. This is not a democratic process. We derive immense value from comments and UserVoice votes, but in the end the governance model for C# is benevolent dictatorship. We think design in a small close-knit group where membership is long-term is the right model for ensuring that C# remains tasteful, consistent, not too big and generally not "designed by committee".
-
-If we don't agree within the design team, that is typically a sign that there are offline activities that can lead to more insight. Usually, at the end of the day, we don't need to vote or have the Language Allfather make a final call.
-
-Prototypes
-----------
-
-Ideally we should prototype every feature we discuss, so as to get a good feel fro the feature and allow the best possible feedback from the community. That may note be realistic, but once we have a good candidate feature, we should try to fly it.
-
-The cost of the prototyping is an issue. This may be feature dependent: Sometimes you want a quick throwaway prototype, sometimes it's more the first version of an actual implementation.
-
-Could be done by a member of the design team, the product team or the community.
-
-Agenda
-------
-
-It's usually up to Mads to decide what's ready to discuss. Generally, if a design team member wants something on the agenda, they get it. There's no guarantee that we end up following the plan in the meeting; the published notes will just show the agenda as a summary of what was *actually* discussed.
-
-
-2. Themes
-=========
-
-If a feature is great, we'll want to add it whether it fits in a theme or not. However, it's useful to have a number of categories that we can rally around, and that can help select features that work well together.
-
-We discussed a number of likely themes to investigate for C# 7.
-
-Working with data
------------------
-
-Today’s programs are connected and trade in rich, structured data: it’s what’s on the wire, it’s what apps and services produce, manipulate and consume.
-
-Traditional object-oriented modeling is good for many things, but in many ways it deals rather poorly with this setup: it bunches functionality strongly with the data (through encapsulation), and often relies heavily on mutation of that state. It is "behavior-centric" instead of "data-centric".
-
-Functional programming languages are often better set up for this: data is immutable (representing *information*, not *state*), and is manipulated from the outside, using a freely growable and context-dependent set of functions, rather than a fixed set of built-in virtual methods. Let’s continue being inspired by functional languages, and in particular other languages – F#, Scala, Swift – that aim to mix functional and object-oriented concepts as smoothly as possible.
-
-Here are some possible C# features that belong under this theme:
-
-- pattern matching
-- tuples
-- "denotable" anonymous types
-- "records" - compact ways of describing shapes
-- working with common data structures (List/Dictionary)
-- extension members
-- slicing
-- immutability
-- structural typing/shapes?
-
-A number of these features focus on the interplay between "kinds of types" and the ways they are used. It is worth thinking of this as a matrix, that lets you think about language support for e.g. denoting the types (*type expressions*), creating values of them (*literals*) and consuming them with matching (*patterns*) :
-
-| Type | Denote | Create | Match |
-|------------|-------------------------|------------------------------|--------------------------|
-| General | `T` | `new T()`, `new T { x = e }` | `T x`, `var x`, `*` |
-| Primitive | `int`, `double`, `bool` | `5`, `.234`, `false` | `5`, `.234`, `false` |
-| String | `string` | `"Hello"` | `"Hello"` |
-| Tuple | `(T1, T2)` | `(e1, e2)` | `(P1, P2)` |
-| Record | `{ T1 x1, T2 x2 }` | `new { x1 = e1, x2 = e2 }` | `{ x1 is P1, x2 is P2 }` |
-| Array | `T[]` | `new T[e]`, `{ e1, e2 }` | `{ P1, P2 }`, `P1 :: P2` |
-| List | ? | ? | ? |
-| Dictionary | ? | ? | ? |
-| ... | | | |
-
-
-A lot of the matrix above is filled in with speculative syntax, just to give an idea of how it could be used.
-
-We expect to give many of the features on the list above a lot of attention over the coming months: they have a lot of potential for synergy if they are designed together.
-
-Performance and reliability (and interop)
------------------------------------------
-
-C# and .NET has a heritage where it sometimes plays a bit fast and loose with both performance and reliability.
-
-While (unlike, say, Java) it has structs and reified generics, there are still places where it is hard to get good performance. A top issue, for instance is the frequent need to copy, rather than reference. When devices are small and cloud compute cycles come with a cost, performance certainly starts to matter more than it used to.
-
-On the reliability side, while (unlike, say, C and C++) C# is generally memory safe, there are certainly places where it is hard to control or trust exactly what is going on (e.g., destruction/finalization).
-
-Many of these issues tend to show up in particular on the boundary to unmanaged code - i.e. when doing interop. Having coarse-grained interop isn't always an option, so the less it costs and the less risky it is to cross the boundary, the better.
-
-Internally at Microsoft there have been research projects to investigate options here. Some of the outcomes are now ripe to feed into the design of C# itself, while others can affect the .NET Framework, result in useful Roslyn analyzers, etc.
-
-Over the coming months we will take several of these problems and ideas and see if we can find great ways of putting them in the hands of C# developers.
-
-Componentization
-----------------
-
-The once set-in-stone issue of how .NET programs are factored and combined is now under rapid evolution.
-
-With generalized extension members as an exception, most work here may not fall in the language scope, but is more tooling-oriented:
-
-- generating reference assemblies
-- static linking instead of IL merge
-- determinism
-- NuGet support
-- versioning and adaptive light-up
-
-This is a theme that shouldn't be driven primarily from the languages, but we should be open to support at the language level.
-
-Distribution
-------------
-
-There may be interesting things we can do specifically to help with the distributed nature of modern computing.
-
-- Async sequences: We introduced single-value asynchrony in C# 5, but do not yet have a satisfactory approach to asynchronous sequences or streams
-- Serialization: we may no longer be into directly providing built-in serialization, but we need to make sure we make it reasonable to custom-serialize data - even when it's immutable, and without requiring costly reflection.
-
-Also, await in catch and finally probably didn't make it into VB 14. We should add those the next time around.
-
-Metaprogramming
----------------
-
-Metaprogramming has been around as a theme on the radar for a long time, and arguably Roslyn is a big metaprogramming project aimed at writing programs about programs. However, at the language level we continue not to have a particularly good handle on metaprogramming.
-
-Extention methods and partial classes both feel like features that could grow into allowing *generated* parts of source code to merge smoothly with *hand-written* parts. But if generated parts are themselves the result of language syntax - e.g. attributes in source code, then things quickly get messy from a tooling perspective. A keystroke in file A may cause different code to be generated into file B by some custom program, which in turn may change the meaning of A. Not a feedback loop we're eager to have to handle in real time at 20 ms keystroke speed!
-
-Oftentimes the eagerness to generate source comes from it being too hard to express your concept beautifully as a library or an abstraction. Increasing the power of abstraction mechanisms in the language itself, or just the syntax for applying them, might remove a lot of the motivation for generated boilerplate code.
-
-Features that may reduce the need for boilerplate and codegen:
-
-- Virtual extension methods/default interface implementations
-- Improvements to generic constraints, e.g.:
- - generic constructor constraints
- - delegate and enum constraints
- - operators or object shapes as constraints (or interfaces), e.g. similar to C++ concepts
-- mixins or traits
-- delegation
-
-Null
-----
-
-With null-conditional operators such as `x?.y` C# 6 starts down a path of more null-tolerant operations. You could certainly imagine taking that further to allow e.g. awaiting or foreach'ing null, etc.
-
-On top of that, there's a long-standing request for non-nullable reference types, where the type system helps you ensure that a value can't be null, and therefore is safe to access.
-
-Importantly such a feature might go along well with proper safe *nullable* reference types, where you simply cannot access the members until you've checked for null. This would go great with pattern matching!
-
-Of course that'd be a lot of new expressiveness, and we'd have to reconcile a lot of things to keep it compatible. In his [blog](http://blog.coverity.com/2013/11/20/c-non-nullable-reference-types), Eric Lippert mentions a number of reasons why non-nullable reference types would be next to impossible to fully guarantee. To be fully supported, they would also have to be known to the runtime; they couldn't just be handled by the compiler.
-
-Of course we could try to settle for a less ambitious approach. Finding the right balance here is crucial.
-
-Themeless in Seattle
---------------------
-
-*Type providers*: This is a whole different kind of language feature, currently known only from F#. We wouldn't be able to just grab F#'s model though; there'd be a whole lot of design work to get this one right!
-
-*Better better betterness*: In C# we made some simplifications and generalizations to overload resolution, affectionately known as "better betterness". We could think of more ways to improve overload resolution; e.g. tie breaking on staticness or whether constraints match, instead of giving compiler errors when other candidates would work.
-
-*Scripting*: The scripting dialect of C# includes features not currently allowed in C# "proper": statements and member declarations at the top level. We could consider adopting some of them.
-
-*params IEnumerable*.
-
-*Binary literals and digit separators*.
-
-
-
-3. Features
-===========
-
-The Matrix above represents a feature set that's strongly connected, and should probably be talked about together: we can add kinds of types (e.g. tuples, records), we can add syntax for representing those types or creating instances of them, and we can add ways to match them as part of a greater pattern matching scheme.
-
-Pattern matching
-----------------
-
-Core then is to have a pattern matching framework in the language: A way of asking if a piece of data has a particular shape, and if so, extracting pieces of it.
-
-``` c#
-if (o is Point(var x, 5)) ...
-```
-
-There are probably at least two ways you want to use "patterns":
-
-1. As part of an expression, where the result is a bool signaling whether the pattern matched a given value, and where variables in the pattern are in scope throughout the statement in which the pattern occurs.
-2. As a case in a switch statement, where the case is picked if the pattern matches, and the variables in the pattern are in scope throughout the statements of that case.
-
-A strong candidate syntax for the expression syntax is a generalization of the `is` expression: we consider the type in an `is` expression just a special case, and start allowing any pattern on the right hand side. Thus, the following would be valid `is` expressions:
-
-``` c#
-if (o is Point(*, 5) p) Console.WriteLine(o.x);
-if (o is Point p) Console.WriteLine(p.x);
-if (p is (var x, 5) ...
-```
-
-Variable declarations in an expression would have the same scope questions as declaration expressions did.
-
-A strong candidate for the switch syntax is to simply generalize current switch statements so that
-
-- the switch expression can be any type
-- the case labels can contain patterns, not just constants
-- the cases are checked in order of appearance, since they can now overlap
-
-``` c#
-switch (o) {
-case string s:
- Console.WriteLine(s);
- break;
-case int i:
- Console.WriteLine($"Number {i}");
- break;
-case Point(int x, int y):
- Console.WriteLine("({x},{y})");
- break;
-case null:
- Console.WriteLine(");
- break
-}
-```
-
-Other syntaxes you can think of:
-
-*Expression-based switch*: An expression form where you can have multiple cases, each producing a result value of the same type.
-
-*Unconditional deconstruction*: It might be useful to separate the deconstruction functionality out from the checking, and be able to unconditionally extract parts from a value that you know the type of:
-
-``` c#
-(var x, var y) = getPoint();
-```
-
-There is a potential issue here where the value could be null, and there's no check for it. It's probably ok to have a null reference exception in this case.
-
-It would be a design goal to have symmetry between construction and deconstruction syntaxes.
-
-Patterns *at least* have type testing, value comparison and deconstruction aspects to them.
-
-There may be ways for a type to specify its deconstruction syntax.
-
-In addition it is worth considering something along the lines of "active patterns", where a type can specify logic to determine whether a pattern applies to it or not.
-
-Imagine positional deconstruction or active patterns could be expressed with certain methods:
-
-``` c#
-class Point {
- public Point(int x, int y) {...}
- void Deconstruct(out int x, out int y) { ... }
- static bool Match(Point p, out int x, out int y) ...
- static bool Match(JObject json, out int x, out int y) ...
-}
-```
-
-We could imagine separate syntax for specifying this.
-
-One pattern that does not put new requirements on the type is matching against properties/fields:
-
-``` c#
-if (o is Point { X is var x, Y is 0 }) ...
-```
-
-Open question: are the variables from patterns mutable?
-
-This has a strong similarity to declaration expressions, and they could coexist, with shared scope rules.
-
-Records
--------
-
-Let's not go deep on records now, but we are aware that we need to reconcile them with primary constructors, as well as with pattern matching.
-
-Array Slices
-------------
-
-One feature that could lead to a lot of efficiency would be the ability to have "windows" into arrays - or even onto unmanaged swaths of memory passed along through interop. The amount of copying that could be avoided in some scenarios is probably very significant.
-
-Array slices represent an interesting design dilemma between performance and usability. There is nothing about an array slice that is functionally different from an array: You can get its length and access its elements. For all intents and purposes they are indistinguishable. So the best user experience would certainly be that slices just *are* arrays - that they share the same type. That way, all the existing code that operates on arrays can work on slices too, without modification.
-
-Of course this would require quite a change to the runtime. The performance consequences of that could be negative even on the existing kind of arrays. As importantly, slices themselves would be more efficiently represented by a struct type, and for high-perf scenarios, having to allocate a heap object for them might be prohibitive.
-
-One intermediate approach might be to have slices be a struct type Slice, but to let it implicitly convert to T[] in such a way that the underlying storage is still shared. That way you can use Slice for high performance slice manipulation (e.g. in recursive algorithms where you keep subdividing), but still make use of existing array-based APIs at the cost of a boxing-like conversion allocating a small object.
-
-ref locals and ref returns
---------------------------
-
-Just like the language today has ref parameters, we could allow locals and even return values to be by `ref`. This would be particularly useful for interop scenarios, but could in general help avoid copying. Essentially you could return a "safe pointer" e.g. to a slot in an array.
-
-The runtime already fully allows this, so it would just be a matter of surfacing it in the language syntax. It may come with a significant conceptual burden, however. If a method call can return a *variable* as opposed to a *value*, does that mean you can now assign to it?:
-
-``` c#
-m(x, y) = 5;
-```
-
-You can now imagine getter-only properties or indexers returning refs that can be assigned to. Would this be quite confusing?
-
-There would probably need to be some pretty restrictive guidelines about how and why this is used.
-
-readonly parameters and locals
-------------------------------
-
-Parameters and locals can be captured by lambdas and thereby accessed concurrently, but there's no way to protect them from shared-mutual-state issues: they can't be readonly.
-
-In general, most parameters and many locals are never intended to be assigned to after they get their initial value. Allowing `readonly` on them would express that intent clearly.
-
-One problem is that this feature might be an "attractive nuisance". Whereas the "right thing" to do would nearly always be to make parameters and locals readonly, it would clutter the code significantly to do so.
-
-An idea to partly alleviate this is to allow the combination `readonly var` on a local variable to be contracted to `val` or something short like that. More generally we could try to simply think of a shorter keyword than the established `readonly` to express the readonly-ness.
-
-Lambda capture lists
---------------------
-
-Lambda expressions can refer to enclosing variables:
-
-``` c#
-var name = GetName();
-var query = customers.Where(c => c.Name == name);
-```
-
-This has a number of consequences, all transparent to the developer:
-- the local variable is lifted to a field in a heap-allocated object
-- concurrent runs of the lambda may access and even modify the field at the same time
-- because of implementation tradeoffs the content of the variable may be kept live by the GC, sometimes even after lambdas directly using them cease to exist.
-
-For these reasons, the recently introduced lambdas in C++ offer the possibility for a lambda to explicitly specify what can be captured (and how). We could consider a similar feature, e.g.:
-
-``` c#
-var name = GetName();
-var query = customers.Where([name]c => c.Name == name);
-```
-This ensures that the lambda only captures `name` and no other variable. In a way the most useful annotation would be the empty `[]`, making sure that the lambda is never accidentally modified to capture *anything*.
-
-One problem is that it frankly looks horrible. There are probably other syntaxes we could consider. Indeed we need to think about the possibility that we would ever add nested functions or class declarations: whatever capture specification syntax we come up with would have to also work for them.
-
-C# always captures "by reference": the lambda can observe and effect changes to the original variable. An option with capture lists would be to allow other modes of capture, notable "by value", where the variable is copied rather than lifted:
-``` c#
-var name = GetName();
-var query = customers.Where([val name]c => c.Name == name);
-```
-This might not be *too* useful, as it has the same effect as introducing another local initialized to the value of the original one, and then capture *that* instead.
-
-If we don't want capture list as a full-blown feature, we could consider allowing attributes on lambdas and then having a Roslyn analyzer check that the capture is as specified.
-
-Method contracts
-----------------
-
-.NET already has a contract system, that allows annotation of methods with pre- and post-conditions. It grew out of the Spec# research project, and requires post-compile IL rewriting to take full effect. Because it has no language syntax, specifying the contracts can get pretty ugly.
-
-It has often been proposed that we should add specific contract syntax:
-``` c#
-public void Remove(string item)
- requires item != null
- ensures Count >= 0
-{
- ...
-}
-
-```
-
-One radical idea is for these contracts to be purely runtime enforced: they would simply turn into checks throwing exceptions (or FailFast'ing - an approach that would need further discussion, but seems very attractive).
-
-When you think about how much code is currently occupied with arguments and result checking, this certainly seems like an attractive way to reduce code bloat and improve readability.
-
-Furthermore, the contracts can produce metadata that can be picked up and displayed by tools.
-
-You could imagine dedicated syntax for common cases - notably null checks. Maybe that is the way we get some non-nullability into the system?
-
diff --git a/docs/designNotes/2015-01-28 C# Design Meeting.md b/docs/designNotes/2015-01-28 C# Design Meeting.md
deleted file mode 100644
index 89f3a0bff59e4..0000000000000
--- a/docs/designNotes/2015-01-28 C# Design Meeting.md
+++ /dev/null
@@ -1,297 +0,0 @@
-C# Design Meeting Notes for Jan 28, 2015
-========================================
-
-Discussion thread for these notes can be found at https://github.com/dotnet/roslyn/issues/180.
-
-Quote of the day:
-
-> It's not turtles all the way down, it's frogs. :-)
-
-Agenda
-------
-
-
-1. Immutable types
-2. Safe fixed-size buffers
-3. Pattern matching
-4. Records
-
-See also [Language features currently under consideration by the language design group](https://github.com/dotnet/roslyn/issues?q=is%3Aopen+label%3A%22Area-Language+Design%22+label%3A%221+-+Planning%22+ "Language Features Under Consideration").
-
-1. Immutable types
-==================
-
-In research prototypes we've experimented with an `immutable` modifier on types, indicating that objects of the type are *deeply* immutable - they recursively do not point to mutable fields. Issue #159 describes the proposal in more detail.
-
-How do we construct types which once fully constructed can't be changed?
-
-- all fields are readonly, and recursively have immutable types
-- can only inherit from other immutable types (or `object`)
-- the constructor can't use "this" other than to access fields
-
-`unsafe` or some other notation could be used to escape scrutiny, in order to create "observable immutability" while cheating under the hood (typically for performance reasons). You could factor such unsafeness into a few types, e.g. `Lazy`.
-
-The feature is designed to work with generics. There would be a new constraint `where T: immutable`. However don't want to bifurcate on `Tuple` vs `ImmutableTuple` just based on whether the content type is constrained to `immutable`.
-
-Instead an immutable `Tuple` would instantiate to immutable types *only* if type arguments are all immutable. So `Tuple` would be immutable, `Tuple` wouldn't be. Immutable generic types would allow type parameters in fields, because that still maintains the recursive guarantee.
-
-Immutable interfaces are also part of the proposal. Somewhat strangely an immutable interface can only be implemented by types that pass all their non-immutable type parameters to the interface!
-
-What's the value? It's mostly a tool for the compiler to help you ensure you are following your intent of writing deeply immutable types.
-
-Why is that a valuable property to ensure in objects?
-- it would allow safe parallel operations over them (modulo holes, see below)
-- it would allow burning an object graph into the DLL by compile time evaluation of static initializers
-- they can be passed to others without defensive copying
-
-Immutable delegates are ones that can only bind to methods on immutable types. At the language level, that means closures would need to be generated as immutable when possible - which it won't often be, unless we adopt readonly parameters and locals (#98, #115).
-
-As for choice of keyword: `readonly` indicates "shallow", that's why `immutable` may be a better word.
-
-Given the restrictions, you'd expect that any method call on an immutable type would have side effects only on data that was passed in to the method - so a parameterless method (or one taking only immutable parameters) would essentially be pure.
-
-Unfortunately that is not quite true. This expectation can be undermined by two things (other than the built-in facility for cheating): mutable static fields and reflection. We can probably live with reflection, that's already a way to undermine so many other language level expectations! However, mutable statics are unfortunate, not just for this scenario but in general. It would be a breaking change to start disallowing them, of course, bu they could be prevented with a Roslyn analyzer.
-
-Even then, while not having side effects, calling such a method twice with the same arguments might not yield the same result: even returning a new object isn't idempotent.
-
-Given the holes and gotchas, the question is whether it is still valuable enough to have this feature? If it's not a full guarantee but mostly a help to not make mistakes, maybe we should do this through attributes and analyzers? The problem with analyzers is that you can't rely on other folks to run them on their code that you depend on. It wouldn't e.g. prevent defensive copies.
-
-In our research project, this turned out to be very valuable in detecting bugs and missed optimization opportunities.
-
-The object freezing could be done without the feature just by carefully analyzing static fields. But the feature might better help people structure things to be ripe for it.
-
-IDE tooling benefits: Extract method would not need to grab all structs by ref.
-
-We would have to consider making it impossible to implement an immutable interface even via the old compiler. Otherwise there's a hole in the system. Something with "modrec"?
-
-If we added a bunch of features that introduce readonly objects to C# 7 (like records, tuples, ...) and then add this feature later, would we end up being in trouble? Only if we violated the rules we would end up applying.
-
-Marking an existing unsealed type as immutable would be a breaking change. If we introduce such classes in C# 7, it would be breaking to make them immutable later.
-
-As a case study, has Roslyn suffered from the lack of this feature? There have been race conditions, but those would still have happened. Is Roslyn not a great example?
-
-Probably not. Roslyn is *not* immutable. It's presenting an immutable *view*, but is mutable inside. Would that be the common case, though?
-
-Some of the "cheating" in Roslyn (caching, free lists, etc) is for performance, some is for representing cycles. Insofar as the immutable types feature is *also* for performance, it seems that thhere's a tension between using it or not.
-
-In summary, we are unsure of the value. Let's talk more.
-
-
-2. Safe Fixed-Size buffers
-==========================
-
-Why are fixed-size buffers unsafe? We could generate safe code for them - at least when not in unsafe regions. Proposal described at #126.
-
-It might generate a lot of code. You could do it with different syntax, or switch on how you generate.
-
-This is a very constrained scenario. It wouldn't be harmful, and a few people would celebrate, but is it worth our effort?
-
-It would allow arbitrary types, not just primitive like today. That may be the bigger value.
-
-Not a high-pri, not one of the first we should commit to.
-
-
-3. Pattern matching
-===================
-
-A view on pattern matching:
-
-A pattern is not an expression, but a separate construct. It can be recursive.
-It's idempotent, doesn't affect the state of the program or "compute" something.
-
-Sktech of possible pattern syntax:
-
-> *pattern:*
- `*`
- *literal*
- `var` *identifier*
- *type* *identifier*opt
- *type* `{` *member* `is` *pattern* ... `}` *identifier*opt
-
-> *expression:*
- *expression* `is` *pattern*
-
-> *switch-label:*
- `case` *pattern* `:`
-
-
-Actually we'd separate into simple and complex patterns and only allow some at the top level.
-
-We'd have to think carefully about semantics to make it fit into existing is expressions and switch statements. Alternatively we'd come up with a new kind of switch statement. The syntax of switch is already among the least appealing parts of C# - maybe time for a revamp anyway?
-
-Additionally we could imagine a switch *expression*, e.g. of the form:
-
-``` c#
-match (e) { pattern => expression; ... ; default => expression }
-```
-This would result in a value, so it would have to be complete - exactly one branch would have to be taken. Maybe an expression would be allowed to throw. In fact, `throw` could be made an expression.
-
-Expanded `is` operator
-----------------------
-
-Here's an example scenario from the Roslyn framework. This should not be taken to say that this is a feature specific to building compilers, though! First, without pattern matching:
-
-``` c#
-var e = s as ExpressionStatement;
-if (e != null) {
- var a = e.Expr as AssignmentExpressionSyntax;
- if (a != null) {
- var l = a.Left as IdentifierName;
- var r = a.RIght as IdentifierName;
- if (l != null && r != null & l.Name.name == r.Name.name) ...
-```
-
-Ugh! With just the `e is T x` non-recursive pattern match we can do a lot better, handling everything in a single if condition:
-
-``` c#
-if (s is ExpressionStatement e &&
- e.Expr is AssignmentExpressionSyntax a &&
- a.Left is IdentifierName l &&
- a.Right is IdentifierName r &&
- l.Name.name == r.Name.name) ...
-```
-
-Much more readable! The explicit null checks and the nesting are gone, and everything still has sensible names.
-
-The test digs pretty deep inside the structure. Here's what if would look like with recursive `T { ... }` patterns:
-
-``` c#
-if (s is ExpressionStatement {
- Expr is AssignmentExpressionSyntax {
- Left is IdentifierName { Name is val l },
- Right is IdentifierName { Name is val r } } }
- && l.name = r.name) ...
-```
-
-Here the pattern match sort of matches the structure of the object itself, nesting patterns for nested objects. It is not immediately obvious which is more readable, though - at least we disagree enthusiastically on the design team about that.
-
-It is possible that the nesting approach has more things going for it, though:
-
-- patterns might not just be type tests - we could embrace "active patterns" that are user defined
-- we could do optimized code gen here, since evaluation order might not necessarily be left to right.
-- the code becomes more readable because the structure of the code matches the shape of the object.
-- the approach of coming up with more top-level variable names may run out of steam the deeper you go.
-
-The `T { ... }` patterns are a little clunky, but would apply to any object. For more conciseness, we imagine that types could specify positional matching, which would be more compactly matched through a `T (...)` pattern.That would significantly shrink the recursive example:
-
-``` c#
-if (s is ExpressionStatement(
- AssignmentExpressionSyntax(IdentifierName l, IdentifierName r))
- && l.name = r.name) ...
-```
-
-This is more concise, but it relies on you knowing what the positions stand for since you are not giving them a name at the consumption site.
-
-So, in summary, it's interesting that the `e is T x` form in itself gives most of the value. The incremental improvement of having recursive patterns may not be all that significant.
-
-Either way, the built-in null check is likely to help with writing null-safe code.
-
-On the tooling side, what would the stepping behavior be? One answer is that there is no stepping behavior. That's already the case inside most expressions. Or we could think it through and come up with something better if the need is there.
-
-The variables are definitely assigned only when true. There is a scoping issue with else if. It's similar to the discussions around declaration expressions in C# 6:
-
-``` c#
-if (o is string s) { ... s ... }
-else if (o is short s) { ... s ... } // error: redeclaration of s
-else ...
-```
-
-All else equal, though not definitely assigned there, the `string s` introduced in the first if condition would also be in scope in the else branch, and the nested if clause would therefore not be allowed to introduce another variable with the same name `s`.
-
-With declaration expressions we discussed having special rules around this, e.g. making variables introduced in an if condition *not* be in scope in the else clause. But this gets weird if you try to negate the condition and swap the branches: all of a sudden the variables would be in scope only where they are *not* definitely assigned.
-
-Expanded `switch` statement
----------------------------
-
-The above examples are in the context of if(...is...), but for switch statements you can't just put `&&...` after the initial pattern. Maybe we would allow a `where ...` (or `when`) in the case labels to add additional filtering:
-
-``` c#
-switch (o) {
-case ExpressionStatement(
- AssignmentExpressionSyntax(IdentifierName l, IdentifierName r)
- where (l.name == r.name):
- ...
-}
-```
-
-If we add pattern matching to switch statements, one side effect is that we generalize the type of thing you can switch on to anything classified as a value.
-
-``` c#
-object o = ...
-switch(o) {
- case 1:
- case 2:
- case 3:
- case Color.Red:
- case string s:
- case *: // no
- case var x: // would have to be last and there'd have to not be a default:
- default:
-}
-```
-We would probably disallow `*`, the wildcard, at the top level. It's only useful in recursive positional notation.
-
-Evaluation order would now be important. For back compat, we would allow default everywhere, and evaluate it last.
-
-We would diagnose situations where an earlier pattern hides a later one:
-
-``` c#
-case Point(*, 2):
-case Point(1, 2): // error/warning
-```
-
-We could allow case guards, which would make the case not subsume other cases:
-
-``` c#
-case Point(var x, 2) where (x > 2):
-case Point(1, 2): // fine
-```
-
-User-defined `is` operator
---------------------------
-
-We've sneaked uses of a positional pattern match above. For that to work, a type would have to somehow specify which positional order to match it in. One very general approach to this would be to allow declaration of an `is` operator on types:
-
-``` c#
-public class Point
-{
- public Point(int x, int y) { this.X = x; this.Y = y; }
- public int X { get; }
- public int Y { get; }
- overrides public int GetHashCode() ...
- overrides public bool Equals(...)...
- public static bool operator is(Point self out int x, out int y) {...}
-}
-```
-
-The operator `is` is a particular way of specifying custom matching logic, similar to F# active patterns. We could imagine less ambitious ways, in particular if we just want to specify deconstruction and not additional logic. That's something to dive into later.
-
-4. Records
-==========
-
-A value-semantics class like the above would be automatically generated by a "record" feature, e.g. from something like:
-
-``` c#
-class Point(int X, int Y);
-```
-
-By default, this would generate all of the above, except parameter names would be upper case. If you want to supercede default behavior, you can give it a body and do that explicitly. For instance, you could make X mutable:
-
-``` c#
-class Point(int X, int Y)
-{
- public int X { get; set; } = X;
-}
-```
-
-You could have syntax to create separate parameter names from member names:
-
-``` c#
-class Point(int x:X, int y:Y)
-{
- public int X { get; set; } = x;
-}
-```
-
-Whether in this form or otherwise, we definitely want to pursue more concise type declarations that facilitate value semantics and deconstruction. We want to pursue the connection with anonymous types and we want to pursue tuples that mesh well with the story too.
-
diff --git a/docs/designNotes/2015-02-04 C# Design Meeting.md b/docs/designNotes/2015-02-04 C# Design Meeting.md
deleted file mode 100644
index 44768eb23369d..0000000000000
--- a/docs/designNotes/2015-02-04 C# Design Meeting.md
+++ /dev/null
@@ -1,294 +0,0 @@
-C# Design Meeting Notes for Feb 4, 2015
-========================================
-
-Discussion thread on these notes can be found at https://github.com/dotnet/roslyn/issues/396.
-
-Agenda
-------
-
-1. Internal Implementation Only (C# 6 investigation)
-2. Tuples, records and deconstruction
-3. Classes with value semantics
-
-
-1. Internal implementation only
-===============================
-
-We have a versioning problem in the Roslyn APIs that we suspect is somewhat common - that of inherited hierarchies.
-
-The essence of the problem is that we want to describe an inheritance *hierarchy* of types in the abstract, as well as several concrete "implementations" of the hierarchy.
-
-In Roslyn, the main example is that we have a language agnostic hierarchy of symbols, as well as a C# and VB specific implementation of that.
-
-This leads to a need for multiple inheritance: "C#-specific local symbol" needs to both inherit "C#-specific symbol" and "abstract local symbol". The only way to represent this is to express the abstract hierarchy with interfaces:
-
-``` c#
-public interface ISymbol { ... }
-public interface ILocalSymbol : ISymbol { ... }
-
-public abstract class CSharpSymbol : ISymbol { ... }
-public class CSharpLocalSymbol : CSharpSymbol, ILocalSymbol { ... }
-
-// Etc...
-```
-
-So far, so good. However, even though `ISymbol` and friends are interfaces, we don't actually want anyone else to implement them. They are not intended as extension points, we merely made them interfaces to allow multiple base types. On the contrary we would like to be able to add members to these types in the future, as the Roslyn API evolves.
-
-Had these types been abstract classes, we could have prevented implementation from other assemblies by having only internal constructors. That would have protected the types for future extensions. However, for interfaces no such trick exists.
-
-As a result, if we ever want to evolve these interfaces by adding more members, but someone implemented them *despite our intent*, we will break those people.
-
-Our options, current and future, seem to include:
-
-1. Tell people really loudly in comments on the interfaces that they shouldn't implement them, because we will break them
-2. Add an attribute, `ImplicitImplementationOnlyAttribute`, to the interfaces
-3. Write an analyzer that enforces the attribute, make it be installed and on by default and hope that catches enough cases
-4. Make the compiler enforce the attribute
-5. Add a mechanism to the language to safely evolve interfaces
- * default implementations of interface methods (like in Java) - will require CLR support
-6. Add an alternative multiple-inheritance mechanism to the language
- * mixins or traits
-
-Options 1, 2 and 3 are open to us today. However, the concern is whether we can consider them strong enough discouragement that our future selves will feel good about evolving the interfaces. If we do 1, 2 and 3, will we then be ready to later break people who disregard the discouragement?
-
-We have never been 100% on compat. Reliance on reflection, codegen patterns etc, can cause code to be breakable today. The BCL has a clear set of guidelines of which things they allow themselves to change even if they can break existing code: adding private fields, etc.
-
-Their rule on interfaces is that we cannot add members to an interface. In inherited-hierarchies situations such as the one in Roslyn that constraint is hard to live with.
-
-Analyzers
----------
-
-Analyzers can easily detect when an interface with the attribute is being implemented outside of its assembly.
-
-The problem here is that it is easy to land in a situation where you do not have the analyzer, or it is not turned on. Analyzers are optional by design: they help you use an API, but the API author can't rely on them being enforced.
-
-Compiler enforcement
---------------------
-
-Moving this check into the compiler would make the "hole" smaller, but, perhaps surprisingly, wouldn't completely deal with it: a pre C# 6 compiler would still happily compile an implementation of an interface with the attribute on. Now, upgrading to C# 6 and the Roslyn-based compiler would be a breaking change!
-
-Also, this may play badly with mocking. Though many of the automated mocking frameworks already have a way to work around internal requirements, explicit or manual mocking would still suffer.
-
-There are probably some design details around how this works in conjunction with `InternalsVisibleTo`:
-
-Assembly A:
-
-``` c#
-[assembly: InternalVisibleTo("B")]
-
-[InternalImplementationOnly]
-public interface IA {}
-```
-
-Assembly B:
-
-``` c#
-public abstract class B : IA {}
-public interface IB : IA {} // implicitly inherits restriction?
-```
-
-Assembly C:
-
-``` c#
-public class C : B {} // OK
-public class D : B, IA {} // not OK
-public class E : IB {} // not OK
-```
-
-Conclusion
-----------
-
-We need to talk to the BCL team to decide whether we would consider either of these approaches sufficient to protect the evolvability of interfaces.
-
-
-
-2. Tuples, records, deconstruction
-==================================
-
-We are eager to look at language support for tuples. They should facilitate multiple return values from methods, including async ones, and a consumption experience that includes deconstruction.
-
-We'll have a proposal ready to discuss in the next meeting (It is now here: #347).
-
-We are also interested in making it much easier to write something akin to algebraic datatypes (discriminated unions), whose shape and contents are easily pattern-matched on and, probably, deconstructed.
-
-While we have a proposal for records that caters to that (#206), there's a sense that this might be more closely connected with the tuple feature than the current proposals suggest, and we should churn on these together to produce a unified, or at least rationalized, design.
-
-Are tuples just a specific kind of record? Are records just tuples with a name? Further exploration is needed!
-
-The next point is one such exploration.
-
-
-3. Classes with values
-======================
-
-We explored a possible pattern for immutable classes. It may or may not be the right thing to do, but it generated a lot of ideas for features that would be possible with it, and that it would be interesting to pursue regardless of the pattern.
-
-The core idea is: if you want value semantics for your object, maybe your object should literally have a `Value`:
-
-``` c#
-public class Person
-{
- public readonly PersonValue Value;
- public Person(PersonValue value) { Value = value; }
- public string Name => Value.Name;
- public int Age => Value.Age;
- …
- public struct PersonValue
- {
- public string Name;
- public int Age;
- }
-}
-```
-
-The core idea is that there is a *mutable* value type representing the actual state. The object wraps a `readonly` field `Value` of that value type and exposes properties that just delegate to the `Value`.
-
-This starts out with the obvious downside that there are two types instead of one. We'll get back to that later.
-
-
-Value semantics
----------------
-
-Value semantics mean a) being immutable and b) having value-based equality (and hash code). Value types *already* have value-based equality and hash code, and the `Value` field is `readonly`. So instead of having to negotiate computation of hashcodes, a developer using this pattern can just forward these questions to the `Value`:
-
-``` c#
-public override bool Equals(object other) => (other as Person)?.Value.Equals(Value) ?? false; // or similar
-public override int GetHashCode() => Value.GetHashCode;
-```
-
-No need to write per-member code. All is taken care of by the `Value`. So for bigger types this definitely leads to less code bloat.
-
-You could implement `IEquatable` for better performance, but this illustrates the point.
-
-
-Builder pattern
----------------
-
-This approach is essentially a version of the Builder pattern: `PersonValue` acts as a builder for `Person` in that it can be manipulated, and eventually passed to the constructor (which implements the Parameter Object pattern by taking all its parameters as one object).
-
-This allows for the use of object initializers in creating new instances:
-
-``` c#
-var person = new Person(new PersonValue { Name = "John Doe" });
-```
-
-It also lets you create new objects from old once using mutation to incrementally change it:
-
-``` c#
-var builder = Person.Value;
-builder.Name = "John Deere";
-person = new Person(builder);
-```
-
-This again scales to much larger objects, and illustrates one of the points why the builder pattern is popular. Another popular approach is to use "Withers", methods for returning a new instance of an immutable type that's incrementally changed in one way from an old one:
-
-``` c#
-person.WithName("John Deere");
-```
-
-Withers are more elegant to use, at least when you are only changing one property. But when changing multiple ones, you need to chain them, creating intermediate objects along the way. What's worse, you need to declare a `WithFoo` method for every single property, which is a lot of boilerplate.
-
-Maybe we can make the Builder pattern more elegant to use - more like the Wither pattern?
-
-
-Object initializers
--------------------
-
-One idea is to allow two new uses of object initializers:
-
-* when creating new immutable objects that implement the builder pattern
-* when non-destructively "modifying" immutable objects by creating new ones with deltas
-
-First, let's allow this (similar to what's proposed in #229):
-
-``` c#
-var person = new Person { Name = "John Doe" };
-```
-
-It would simply rewrite to this:
-
-``` c#
-var person = new Person(new PersonValue { Name = "John Doe" });
-```
-
-Which is what we had above.
-
-Second, let's allow object initializers on *existing* values instead of just new expressions. This is a much requested feature already, because it would apply to factories etc.
-
-It would allow us to do a lot better on the incremental modification:
-
-``` c#
-person = new Person(person.Value { Name = "John Deere" });
-```
-
-If we are uncomfortable just letting object initializers occur directly on any expression, we could consider adding a keyword, like `with`.
-
-Now we can get the builder, modify it and create a new Person from it, all in one expression.
-
-But of course the kicker is to combine the two ideas, allowing you to write:
-
-``` c#
-person = person { Name = "John Deere" };
-```
-
-to the same effect:
-
-* Since `person` doesn't have a writable member `Name`, get its builder
-* modify the builder based on the object initializer
-* create a new `Person` from the builder
-
-So in summary, adding the builder patter in *some* compiler-recognized form allows us to tinker with the object initializer feature, making it work as well for immutable objects as it does for mutable ones, and essentially serving as built-in "wither" support.
-
-
-Using tuples as the values
---------------------------
-
-Tuples are far from a done deal, but assuming a design like #347, where tuples are mutable structs, they could actually serve as the type of the `Value` field, thus obliterating the need for a second type declaration:
-
-``` c#
-public class Person
-{
- public readonly (string Name, int Age) Value; // a tuple
- public Person((string Name, int Age) value) { Value = value; }
- …
-}
-```
-
-This opens up one more opportunity. Assuming you want your immutable type to be deconstructable the same way as a tuple - by position. How do you indicate that? Well maybe having a tuple as your `Value` is how: deconstruction is simply yet another aspect that is delegated to the `Value`:
-
-``` c#
-(var n, var a) = GetPerson(); // deconstructed as per the `Value` tuple
-```
-
-Records
--------
-
-If we have a pattern that the compiler supports in various ways for immutable types (whether this pattern or another), it makes sense that that pattern should also underlie any record syntax that we add.
-
-Assuming a record syntax like in #206, the record definition:
-
-``` c#
-class Person(string Name, int Age);
-```
-
-Would then generate the class
-
-``` c#
-class Person
-{
- public readonly (string Name, int Age) Value;
- public Person((string Name, int Age) value) { Value = value; }
- public string Name => Value.Name;
- public int Age => Value.Age;
- public override bool Equals(object other) => (other as Person)?.Value.Equals(Value) ?? false; // or similar
- public override int GetHashCode() => Value.GetHashCode;
-}
-```
-
-And would therefore support object initializers and positional deconstruction.
-
-
-Conclusion
-----------
-
-We are not at all sure if this is the right general direction, let alone the right *specific* pattern if it is. But builders are a common pattern, and for a reason. It would be interesting if support for them was somehow included in what we do for immutable types in C# 7.
diff --git a/docs/designNotes/2015-02-11 C# Design Meeting.md b/docs/designNotes/2015-02-11 C# Design Meeting.md
deleted file mode 100644
index e82a75bc2251d..0000000000000
--- a/docs/designNotes/2015-02-11 C# Design Meeting.md
+++ /dev/null
@@ -1,305 +0,0 @@
-C# Design Meeting Notes for Feb 11, 2015
-=========================================
-
-Discussion on these notes can be found at https://github.com/dotnet/roslyn/issues/1207.
-
-Agenda
-------
-
-1. Destructible types <*we recognize the problem but do not think this is quite the right solution for C#*>
-2. Tuples <*we like the proposal, but there are several things to iron out*>
-
-
-
-1. Destructible types
-=====================
-
-Issue #161 is a detailed proposal to add destructible types to C#.
-
-The problem area is deterministic disposal of resources.
-
-Finalizers are notoriously non-deterministic (you can never know when or even whether they run), and rampant usage is quite a hit on performance. `using` statements are the language's current attempt at providing for deterministic disposal.
-
-The problem with `using` statements is that no-one is forced to use them. An `IDisposable` resource is disposed of only if people remember to wrap it in a `using`. FxCop rules and now Roslyn diagnostics can be employed to help spot places where things aren't disposed that should be, but these have notoriously run into false positives and negatives, to the extent that they are a real nuisance and often get turned off.
-
-At least one reason for this is the lack of their ability to track ownership. Whose responsibility is it to ultimately dispose the resource, and how is that responsibility transferred?
-
-Destructible types offer a sweeping approach to deal with this, that is a complete departure from `using` and `IDisposable` and instead leans more closely on C++-like RAII features.
-
-The core idea is that destructible types are a language concept (they have to be declared as such):
-
-``` c#
-destructible struct Handle
-{
- IntPtr ptr;
-
- ~Handle()
- {
- if (ptr != IntPtr.Zero) Free(ptr);
- }
-}
-```
-
-Destructible types can only be fields in other destructible types.
-
-Variables of destructible type have their contents automatically disposed when they go out of scope.
-
-To prevent multiple disposal, such variables can't just be assigned to others. Instead, ownership must be explicitly transferred (with a `move` keyword):
-
-``` c#
-void M()
-{
- Handle h = CreateHandle();
- Handle h2 = h; // Not allowed! Moves are explicit
- Handle h3 = move h; // Explicit owner transfer
-
- M2(new Handle()); // ok, no owner
- M2(h3); // Not allowed!
- M2(move h3); // ok, explicit owner transfer
-
-}
-void M2(Handle h) ...
-```
-
-At the end of M, all locals with destructible types are destructed, in opposite order of their introduction.
-
-Additionally variables can be "borrowed" by being passed by `ref` to a method.
-
-There are a lot of limitations to the feature, and it doesn't replace `IDisposable`, because you cannot use destructible types as type arguments, in arrays, and as fields of non-destructible types. Also, they cannot implement interfaces.
-
-As a release valve one can have a `Box` that "magically" transfers the ownership of a destructible type to the finalizer. The finalizer will crash the process if the destructible hasn't been properly destructed.
-
-There has been some negative feedback around the destruction being implicit, even as the ownership transfer was explicit. When assignment overwrites a value, that value has to be destructed. But what about cases like this?
-
-``` c#
-{
- D x;
- if (e) x = new x();
- x = new x();
-}
-```
-
-How to know whether the second assignment overwrites a value, that should therefore be destructed? We'd have to keep track at runtime. Or prevent this situation through definitely assigned or unassigned rules, or the like.
-
-
-Conclusion
-----------
-
-Overall, we see how this adds value, but not enough that having these concepts in the face of all C# developers. It doesn't earn back it's -100 points.
-
-Could we take a step back and have analyzers encourage practices that are less error prone? Yes. You just cannot have analyzers enforce correctness. And you cannot have them improve perf by affecting codegen. And they cannot do the heavy lifting for you.
-
-An analyzer can help you with where to put your `using` statements. FxCop tries to do that today, but has too many false positives (use vs ownership). Even if you could get rid of those, there's a lot of code you'd need to write.
-
-People do struggle with `IDisposable` today. They don't know when things are `IDisposable`, whether they are the ones who should dispose things.
-
-We would like to solve the problem in C#, and pick over this proposal for ideas, but we'd need to noodle with it to make it a better fit. It would need to integrate better with current `IDisposable`.
-
-
-
-2. Tuples
-=========
-
-Issue #347 is a proposal for adding tuples to C#. The main guiding principle for the proposal is to enable multiple return values, and wherever possible design them in analogy with parameter lists.
-
-As such, a tuple type is a parenthesized list of types and names, just like a parameter list:
-
-``` c#
-public (int sum, int count) Tally(IEnumerable values) { ... }
-
-var t = Tally(myValues);
-Console.WriteLine($"Sum: {t.sum}, count: {t.count}");
-```
-
-Along the same lines, tuple values can be constructed using a syntax similar to argument lists. By position:
-
-``` c#
-public (int sum, int count) Tally(IEnumerable values)
-{
- var sum = 0; var count = 0;
- foreach (var value in values) { sum += value; count++; }
- return (sum, count); // target typed to the return type
-}
-```
-
-Or by name:
-
-``` c#
-public (int sum, int count) Tally(IEnumerable values)
-{
- var res = (sum: 0, count: 0); // infer tuple type from names and values
- foreach (var value in values) { res.sum += value; res.count++; }
- return res;
-}
-```
-
-Finally, there'd be syntax to deconstruct tuples into variables for the individual members:
-
-``` c#
-(var sum, var count) = Tally(myValues); // deconstruct result
-Console.WriteLine($"Sum: {sum}, count: {count}");
-```
-
-Tuples should be thought of as temporary, ephemeral constellations of values without inherent conceptual connection: they just "happen to be traveling together".
-
-We are generally eager to pursue this design. There are a number of open issues, that we explore in the following.
-
-
-Type equivalence
-----------------
-
-Intuitively you'd expect that every time you use the same tuple type expression, it denotes the same type - that there is *structural equivalence*. However, depending on how we implement tuple types on top of the CLR, that may not always be easy to achieve - especially when unifying across different assemblies.
-
-To take it to an extreme, what if they didn't even unify *within* an assembly? Even then they'd probably have significant value. They would be good for the "ephemeral" core scenario of things traveling together. It wouldn't let them serve as e.g. builders; they would really only work for the multiple return values scenario.
-
-Even then there'd be issues with virtual method overrides, etc: When you override and restate the return type, it doesn't really work if that declares a *different* return type.
-
-``` c#
-class C
-{
- public abstract (int x, int y) GetCoordinates();
-}
-class D : C
-{
- public override (int x, int y) GetCoordinates() { ... } // Error! different return type!!?!
-}
-```
-
-A middle ground is for these methods to unify *within* but not *across* assemblies. This is what we do for anonymous types today. However, there we are careful never to let the types occur in member signatures, whereas that would be the whole point of tuples.
-
-This makes a little more sense than no unification at all, since at least all mentions of a tuple type within the same member body and even type body refer to the same type. However there'd still be weird behavior involving overrides across assembly boundaries, equivalence of generic types constructed with tuple types, etc. We could try to be smart about reusing types from other assemblies when possible, etc, but it would be quite a game of whack-a-mole to get all the edge cases behaving sensibly.
-
-The only thing that really makes sense at the language level is true structural equivalence. Unfortunately, the CLR doesn't really provide for unification of types with similar member names across assemblies. Ideally we could *add* that to the CLR, but adding new functionality to the CLR is not something to be done lightly, as it breaks all downlevel targeting.
-
-A way to get structural equivalence working at compile time would be to encode tuples with framework types similar to the current `Tuple<...>` types. Member access would be compiled into access of members called `Item1` etc. The language level member names would be encoded in attributes for cross-assembly purposes:
-
-``` c#
-struct VTuple2 { ... }
-struct VTuple3 { ... }
-
-/* Source: */
-(x: int, y: int) f() { ... }
-
-/* Generates: */
-[TupleNames("x", "y")]
-VTuple2 f() {...}
-```
-
-Unfortunately this leaves problems at runtime: now there's *too much* type equivalence. If I want to do a runtime test to see if an object is an `(int x, int y)`, I would get false positives for an `(int a, int b)`, since the names wouldn't be part of the runtime type:
-
-``` c#
-object o = (a: 7, b: 9);
-if (o is (int x, int y) t) WriteLine(t.x); // false positive
-```
-
-Also the member names would be lost to `dynamic`:
-
-``` c#
-dynamic d = (a: 7, b: 9);
-WriteLine(t.a); // Error! Huh ??!?
-```
-
-
-Of course we could come up with tricks so that a tuple would carry some kind of member name info around at runtime, but not without cost. Or we could decide that the names are ephemeral, compile time only entities, kind of like parameter names, and losing them when boxing is actually a good thing.
-
-Also, this approach means that languages that don't know about tuples would see the actual `Item1` member names when referencing member signatures containing tuples. Such languages include previous versions of C#! So for compatibility with those versions of C#, even in the new, tuple-aware, version, access through `Item1` etc would have to be still legal (though probably hidden from IntelliSense etc.).
-
-A nice thing about this scheme is that it leads to very little code bloat: it only relies on framework types, and not on compiler generated types in the assembly.
-
-This remains an issue for further debate.
-
-
-Conversions
------------
-
-There are several kinds of conversions you can imagine allowing between tuple types:
-
-``` c#
-(string name, int age) t = ("Johnny", 29);
-
-/* Covariance */
-(object name, int age) t1 = t;
-
-/* Truncation */
-(object name) t2 = t;
-
-/* Reordering */
-(int age, string name) t3 = t;
-
-/* Renaming */
-(string n, int a) t4 = t;
-```
-
-Note that you cannot have both reordering and renaming in the language; we would have to choose.
-
-However, we are more inclined not to allow *any* of these conversions. They don't seem particularly helpful, and are likely to mask something you did wrong. People can always deconstruct and reconstruct if they want to get to a different tuple type, so our default position is to be super rigid here and only match exactly the same names and types in exactly the same order.
-
-
-Deconstruction
---------------
-
-There are a couple of issues with the proposed deconstruction syntax.
-
-First of all, since the recipient variables are on the left, there is no equivalent to parameter help guiding you as to what to name them. In that sense it would be better to have a syntax that receives the values on the right. But that seems an odd place to declare new variables that are intended to be in scope throughout the current block:
-
-``` c#
-Tally(myValues) ~> (var sum, var count); // strawman right side alternative
-Console.WriteLine($"Sum: {sum}, count: {count}");
-```
-
-That's not an actual proposed syntax, but just intended to show the point!
-
-A related issue is that you'd sometimes want to deconstruct into *existing* variables, not declare new ones:
-
-``` c#
-(sum, count) = Tally(myValues);
-```
-
-Should this be allowed? Is deconstruction then a declaration statement, an assignment statement or something different?
-
-Finally, once we have a deconstruction syntax, we'd probably want to enable it for other things than tuples. Maybe types can declare how they are to be deconstructed, in a way that the language understands. So deconstruction syntax should be considered in this broader context. For instance, if deconstructable types can be reference types, can deconstruction throw a null reference exception?
-
-
-LINQ
-----
-
-You could imagine tuples becoming quite popular in LINQ queries, to the point of competing with anonymous types:
-
-``` c#
-from c in customers
-select (name: c.Name, age: c.Age) into p
-where p.name == "Kevin"
-select p;
-```
-
-To this end it would be useful for tuple "literals" to support *projection*, i.e. inference of member names, like anonymous types do:
-
-``` c#
-from c in customers
-select (c.Name, c.Age) into p // infers (string Name, int Age)
-where p.Name == "Kevin"
-select p;
-```
-
-
-Out parameters
---------------
-
-F# allows out parameters to be seen as additional return values. We could consider something similar:
-
-``` c#
-bool TryGet(out int value){ ... }
-
-/* current style */
-int value;
-bool b = TryGet(out value);
-
-/* New style */
-(int value, bool b) = TryGet();
-```
-
-
-Conclusion
-----------
-
-We'd very much like to support tuples! There are a number of open questions, as well as interactions with other potential features. We'll want to keep debating and experimenting for a while before we lock down a design, to make sure we have the best overall story.
\ No newline at end of file
diff --git a/docs/designNotes/2015-03-04 C# Design Meeting.md b/docs/designNotes/2015-03-04 C# Design Meeting.md
deleted file mode 100644
index 40ef5396e9f45..0000000000000
--- a/docs/designNotes/2015-03-04 C# Design Meeting.md
+++ /dev/null
@@ -1,140 +0,0 @@
-C# Design Meeting Notes for Mar 4, 2015
-========================================
-
-Discussion on these notes can be found at https://github.com/dotnet/roslyn/issues/1303.
-
-Agenda
-------
-
-1. `InternalImplementationOnly` attribute <*no*>
-2. Should `var x = nameof(x)` work? <*no*>
-3. Record types with serialization, data binding, etc. <*keep thinking*>
-4. "If I had a [billion dollars](http://www.infoq.com/presentations/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare)...": nullability <*daunting but worth pursuing*>
-
-
-
-1. InternalImplementationOnly
-=============================
-
-This was a last-minute proposal for C# 6 and VB 14 to recognize and enforce an attribute to the effect of disallowing non-internal implementation of an interface. It would be useful to represent "abstract hierarchies", while reserving the right to add new members at a later stage.
-
-
-Conclusion
-----------
-
-Let's not do this. We cannot enforce it well enough since old compilers don't know about it.
-
-
-
-2. Should `var x = nameof(x)` work?
-===================================
-
-This was raised as issue #766.
-
-``` c#
-var POST = nameof(POST);
-```
-
-
-Conclusion
-----------
-
-This works the same as with any other construct, i.e.: not. This is not a special case for `nameof`, and it doesn't seem worth special casing to allow it.
-
-
-
-3. Records
-==========
-
-There's general excitement around proposals such as #206 to add easier syntax for declaring "records", i.e. simple data shapes.
-
-This discussion is about the degree to which such a feature should accommodate interaction with databases, serialization and UI data binding.
-
-The problem has compounded in recent times. In a mobile app, pretty much everything has to be serialized one way or another. There's a big difference between e.g. JSON and binary serialization. In one you want readable property names (in a certain format), in the other you want compactness. ORMs are also essentially serialization. POCO was invented in that same context, but only gets you part of the way there.
-
-Clearly, tying the language feature to specific such technologies is not a sustainable idea. There will not be built-in JSON literals, or `INotifyPropertyChanged` implementation or anything like that.
-
-That said, It is worth thinking about what can be done *in general* to support such features better.
-
-One problem is that each specific serialization and data binding technology tends to have certain requirements of the shape of the data objects. Serialization frameworks may expect the fields to be mutable, or to have certain attributes on them. UIs may expect properties to notify on change. Such requirements make it hard to have a single language-sanctioned mechanism for specifying the data shapes.
-
-A separate problem may be the degree to which reflection is used by these technologies. It is commonly used to get at metadata such as member names, but is also sometimes used to set or get the actual values. It ends up being the case that both serialization and UI use the objects only in a "meta" fashion; the only part of the program that actually makes use of the data in a strongly typed way ends up being the business logic in between.
-
-So in effect, data objects need to both facilitate strongly typed business logic based on their property names and shapes (and often in hierarchies), *and* satisfy requirements that are specific to the serialization and UI environments they are used in. Cross-cutting aspects, one might say, that clash in the implementation of the data objects.
-
-There are several possible approaches, not necessarily mutually exclusive:
-
-**Write the data types manually**: Often what ends up happening today. Just grit your teeth and churn out those INotifyPropertyChanged implementations.
-
-**Separate objects**: Often the "best practice" is to have separate objects for serialization, logic, and presentation. But having to write the glue code between these is a big pain, and people often have to do at least some of it manually.
-
-**Non-reflective meta-level access model**: E.g. implement dictionary-like behavior. Prevents need for reflection, but is it actually better or faster?
-
-**"Fake" types**: Maybe at runtime the data objects shouldn't have strongly typed properties at all. Maybe the business logic is written up against a new kind of types that are only there at compile time, and which either simply erase like in TypeScript, or cause weakly typed but smart access code to be generated like with F# type providers. Then, from the perspective of serialization and UI, all the objects have the same type.
-
-**Compile-time metaprogramming**: Generate the types (either into source or IL) from code describing the data shapes, adding whatever serialization or presentation functionality is required.
-
-A particularly common requirement of these frameworks is for the data properties to be mutable. That might clash spectacularly with a records feature that tries to encourage immutability by default.
-
-
-Conclusion
-----------
-
-We'll keep thinking about this situation. A next step in particular is to reach out to teams that own the serialization and presentation technologies that we'd like to work well with.
-
-
-
-Nullability and reference types
-===============================
-
-The horrifying thing about null being allowed as a member of reference types is that it does not obey the contract of those types. Reference types can be null *and* reference types can be dereferenced, But dereferencing null is a runtime error! No wonder Sir Tony famously calls null pointers his "[billion dollar mistake](http://www.infoq.com/presentations/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare)".
-
-There are type systems that prevent null reference errors, and it is easy enough to do. It takes different shapes in different languages, but the core of it is that there is a non-nullable kind of reference type that can be dereferenced but cannot be null, and a nullable "wrapper" of that, which *can* be null, but cannot be dereferenced. The way you go from nullable to nonnullable is through a guard to test that the nullable value wasn't in fact null. Something like:
-
-``` c#
-string? n; nullable string
-string! s; non-nullable string
-
-n = null; // Sure; it's nullable
-s = null; // Error!
-
-WriteLine(s.Length); // Sure; it can't be null so no harm
-WriteLine(n.Length); // Error!
-if (n is string! ns) WriteLine(ns.Length); // Sure; you checked and dug out the value
-```
-
-Of course, if such a type system were around from day one, you wouldn't need the `!` annotation; `string` would just *mean* non-nullable.
-
-It's a very common request (in fact [the top C# request on UserVoice](http://visualstudio.uservoice.com/forums/121579-visual-studio/category/30931-languages-c)) for us to do something about null reference exceptions along those lines. There are numerous obstacles, however:
-
-**Backward compatibility**: The cat is already very much out of the bag in that existing code needs to continue to compile without error - no matter how null-unsafe it is. The best we can do about *existing* code is to offer optional analyzers to point out dangerous places.
-
-**A default value for all types**: It is deeply ingrained in .NET and the CLR that every type has a default value. When you create an array with `new T[10]`, the array elements are initialized to the default value of `T`. There's even syntax to get the default value of a type, `default(T)`, and it is allowed even on unconstrained type parameters. But what is the default value of a non-nullable reference type?
-
-**Definite assignment of non-nullable fields is unenforceable**. Eric Lippert explains it well [on his blog](http://blog.coverity.com/2013/11/20/c-non-nullable-reference-types/).
-
-**Evolving libraries is breaking**: Say we added non-null annotations to the language. You'd then want to use them on your existing libraries to provide further guidance to your clients. Adding them on parameters would of course be breaking:
-
-``` c#
-public void Foo(string! name) { ... } // '!' newly added
-
-Foo(GetString()); // Unless GetString also annotated, this is now broken
-```
-
-More subtly, adding the extra guarantee of non-nullability to a *return* type would also be breaking:
-
-``` c#
-public string! Foo() { ... } // '!' newly added
-
-var s = Foo(); // Now infers 'string!' instead of 'string' for s
-...
-s = GetString(); // So this assignment is now broken
-```
-
-Type inference and overload resolution generally make strengthening of return types a potentially breaking change, and adding non-nullability is just a special case of that.
-
-
-Conclusion
-----------
-
-Moving C# to a place of strong guarantees around nullability seems out of the question. But that is not to say that we cannot come up with an approach that meaningfully reduces the number of null reference exceptions. We want to keep digging here to see what can be done. The perfect is definitely the enemy of the good with this one.
\ No newline at end of file
diff --git a/docs/designNotes/2015-03-10,17 C# Design Meeting.md b/docs/designNotes/2015-03-10,17 C# Design Meeting.md
deleted file mode 100644
index e2da37d1cdd31..0000000000000
--- a/docs/designNotes/2015-03-10,17 C# Design Meeting.md
+++ /dev/null
@@ -1,170 +0,0 @@
-C# Design Meeting Notes for Mar 10 and 17, 2015
-===============================================
-
-Discussion thread for these notes can be found at https://github.com/dotnet/roslyn/issues/1648.
-
-Agenda
-------
-
-These two meetings looked exclusively at nullable/non-nullable reference types. I've written them up together to add more of the clarity of insight we had when the meetings were over, rather than represent the circuitous path we took to get there.
-
-1. Nullable and non-nullable reference types
-2. Opt-in diagnostics
-3. Representation
-4. Potentially useful rules
-5. Safely dereferencing nullable reference types
-6. Generating null checks
-1. Nullable and non-nullable reference types
-============================================
-
-The core features on the table are nullable and non-nullable reference types, as in `string?` and `string!` respectively. We might do one or both (or neither of course).
-
-The value of these annotations would be to allow a developer to express intent, and to get errors or warnings when working against that intent.
-
-
-
-2. Opt-in diagnostics
-=====================
-
-However, depending on various design and implementation choices, some of these diagnostics would be a breaking change to add. In order to get the full value of the new feature but retain backward compatibility, we therefore probably need to allow the enforcement of some or most of these diagnostics to be *opt-in*. That is certainly an uncomfortable concept, and adding switches to the language changing its meaning is not something we have much of an appetite for.
-
-However, there are other ways of making diagnostics opt-in. We now have an infrastructure for custom analyzers (built on the Roslyn infrastructure). In principle, some or all of the diagnostics gained from using the nullability annotations could be custom diagnostics that you'd have to switch on.
-
-The downside of opt-in diagnostics is that we can forget any pretense to guarantees around nullability. The feature would help you find more errors, and maybe guide you in VS, but you wouldn't be able to automatically trust a `string!` to not be null.
-
-There's an important upside though, in that it would allow you to gradually strengthen your code to nullability checks, one project at a time.
-
-
-
-3. Representation
-=================
-
-The representation of the annotations in metadata is a key decision point, because it affects the number of diagnostics that can be added to the language itself without it being a breaking change. There are essentially four options:
-
-1. Attributes: We'd have `string?` be represented as `string` plus an attribute saying it's nullable. This is similar to how we represent `dynamic` today, and for generic types etc. we'd use similar tricks to what we do for `dynamic` today.
-
-2. Wrapper structs: There'd be struct types `NullableRef` and `NonNullableRef` or something like that. The structs would have a single field containing the actual reference.
-
-3. Modreq's: These are annotations in metadata that cause an error from compilers that don't know about them.
-
-4. New expressiveness in IL: Something specific to denote these that only a new compiler can even read.
-
-We can probably dispense with 3 and 4. We've never used modreq's before, and who knows how existing compilers (of all .NET languages!) will react to them. Besides, they cannot be used on type arguments, so they don't have the right expressiveness. A truly new metadata annotation has similar problems with existing compilers, and also seems like overkill.
-
-Options 1 and 2 are interesting because they both have meaning to existing compilers.
-
-Say a library written in C# 7 offers this method:
-
-``` c#
-public class C
-{
- string? M(string! s) { ... }
-}
-```
-
-With option 1, this would compile down to something like this:
-
-``` c#
-public class C
-{
- [Nullable] string M([NonNullable] string s) { ... }
-}
-```
-
-A consuming program in C# 6 would not be constrained by those attributes, because the C# 6 compiler does not know about them. So this would be totally fine:
-
-``` c#
-var l = C.M(null).Length;
-```
-
-Unfortunately, if something is fine in C# 6 it has to also be fine in C# 7. So C# 7 cannot have rules to prevent passing null to a nonnullable reference type, or prevent dereferencing a nullable reference type!
-
-That's obviously a pretty toothless - and hence useless - version of the nullability feature in and of itself, given that the value was supposed to be in getting diagnostics to prevent null reference exceptions! This is where the opt-in possibility comes in. Essentially, if we use an attribute encoding, we need all the diagnostics that make nullability annotations useful be opt-in, e.g. as custom diagnostics.
-
-With option 2, the library would compile down to this:
-
-``` c#
-public class C
-{
- NullableRef M(NonNullableRef s) { ... }
-}
-```
-
-Now the C# 6 program above would not compile. The C# 6 compiler would see structs that can't be null and don't have a Length. Whatever members those structs *do* have, though, would be accessible, so C# 7 would still have to accept using them as structs. (We could mitigate this by not giving the structs any public members).
-
-For the most part, this approach would make the C# 6 program able to do so little with the API that C# 7, instead of adding *restrictions*, can allow *more* things than C# 6.
-
-There are exceptions, though. For instance, casting any returned such struct to `object` would box it in C# 6, whereas presumably the desired behavior in C# 7 would be to unwrap it. This is exactly where the CLR today has special behavior, boxing nullable value types by first unwrapping to the underlying type if possible.
-
-Also, having these single-field structs everywhere is likely going to have an impact on runtime performance, even if the JIT can optimize many of them away.
-
-Probably the most damning objection to the wrapper structs is probably the degree to which they would hamper interoperation between the different variations of a type. For instance, the conversion from `string!` to `string` and on to `string?` wouldn't be a reference conversion at runtime. Hence, `IEnumerable` wouldn't convert to `IEnumerable`, despite covariance.
-
-We are currently leaning strongly in the direction of an attribute-based representation, which means that there needs to be an opt-in mechanism for enforcement of the useful rules to kick in.
-
-
-
-4. Potentially useful rules to enforce
-======================================
-
-**Don't dereference `C?`**: you must check for null or assert that the value is not null.
-
-**Don't pass `null`, `C` or `C?` to `C!`:** you must check for null or assert that the value is not null.
-
-**Don't leave `C!` fields unassigned:** require definite assignment at the end of the constructor. (Doesn't prevent observing null during initialization)
-
-**Avoid `default(C!)`:** it would be null!
-
-**Don't instantiate `C![]`:** it's elements would be null. This seems like a draconian restriction - as long as you only ever read fields from the array that were previously written, no-one would observe the default value. Many data structures wrapping arrays observe this discipline.
-
-**Don't instantiate `G`:** this is because the above rules aren't currently enforced on even unconstrained type parameters, so they could be circumvented in generic types and methods. Again, this restriction seems draconian. No existing generic types could be used on nonnullable reference types. Maybe the generic types could opt in?
-
-**Don't null-check `C!`:** oftentimes using e.g. `?.` on something that's already non-nullable is redundant. However, since non-nullable reference types *can* be null, maybe flagging such checks is not always so helpful?
-
-We very much understand that these rules can't be perfect. The trade-off needs to be between adding value and allowing continuity with existing code.
-
-
-
-5. Safely dereferencing nullable reference types
-================================================
-
-For nullable reference types, the main useful error would come from dereferencing the value without checking for null. That would often be in the shape of the null-conditional operator:
-
-``` c#
-string? s = ...;
-var l = s?.Length;
-var c = s?[3];
-```
-
-However, just as often you'd want the null test to guard a block of code, wherein dereferencing is safe. An obvious candidate is to use pattern matching:
-
-``` c#
-string? ns = ...;
-if (ns is string! s) // introduces non-null variable s
-{
- var l = s.Length;
- var c = s[3];
-}
-```
-
-It is somewhat annoying to have to introduce a new variable name. However, in real code the expression being tested (`ns` in the above example) is more likely to be a more complex expression, not just a local variable. Or rather, the `is` expression is how you'd get a local variable for it in the first place.
-
-More annoying is having to state the type again in `ns is string! s`. We should think of some shorthand, like `ns is ! s` or `ns is var s` or something else.
-
-Whatever syntax we come up with here would be equally useful to nullable *value* types.
-
-
-
-6. Generating null checks for parameters
-========================================
-
-There'd be no guarantees that a `string!` parameter actually isn't going to be null. Most public API's would probably still want to check arguments for null at runtime. Should we help with that by automatically generating null checks for `C!` parameters?
-
-Every generated null check is performance overhead and IL bloat. So this may be a bad idea to do on every parameter with a non-nullable reference type. But we could have the user more compactly indicate the desire to do so. As a complete strawman syntax:
-
-``` c#
-public void M(string!! s) { ... }
-```
-Where the double `!!` means the type is non-nullable *and* a runtime check should be generated.
-
-If we choose to also do contracts (#119), it would be natural for this feature to simply be a shorthand for a null-checking `requires` contract.
diff --git a/docs/designNotes/2015-03-18 C# Design Meeting.md b/docs/designNotes/2015-03-18 C# Design Meeting.md
deleted file mode 100644
index d8fa33e006b63..0000000000000
--- a/docs/designNotes/2015-03-18 C# Design Meeting.md
+++ /dev/null
@@ -1,186 +0,0 @@
-C# Design Meeting Notes for Mar 18, 2015
-========================================
-
-Discussion thread for these notes can be found at https://github.com/dotnet/roslyn/issues/1677
-
-Agenda
-------
-
-In this meeting we looked over the top [C# language feature requests on UserVoice](http://visualstudio.uservoice.com/forums/121579-visual-studio/category/30931-languages-c) to see which ones are reasonable to push on further in C# 7.
-
-
-
-1. Non-nullable reference types (*already working on them*)
-2. Non-nullary constructor constraints (*require CLR support*)
-3. Support for INotifyPropertyChanged (*too specific; metaprogramming?*)
-4. GPU and DirectX support (*mostly library work; numeric constraints?*)
-5. Extension properties and static members (*certainly interesting*)
-6. More code analysis (*this is what Roslyn analyzers are for*)
-7. Extension methods in instance members (*fair request, small*)
-8. XML comments (*Not a language request*)
-9. Unmanaged constraint (*requires CLR support*)
-10. Compilable strings (*this is what nameof is for*)
-11. Mulitple returns (*working on it, via tuples*)
-12. ISupportInitialize (*too specific; hooks on object initializers?*)
-13. ToNullable (*potentially part of nullability support*)
-14. Statement lambdas in expression trees (*fair request, big feature!*)
-15. Language support for Lists, Dictionaries and Tuples (*Fair; already working on tuples*)
-
-A number of these are already on the table.
-
-
-
-1. Non-nullable reference types
-===============================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2320188-add-non-nullable-reference-types-in-c](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2320188-add-non-nullable-reference-types-in-c)
-
-We're already working on this; see e.g. #1648.
-
-
-
-2. Non-nullary constructor constraints
-======================================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2122427-expand-generic-constraints-for-constructors](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2122427-expand-generic-constraints-for-constructors)
-
-It is odd that we only support the `new()` constraint for empty parameter lists. In order to generalize this, however, we'd need CLR support to express it - see #420.
-
-
-
-3. Support for INotifyPropertyChanged
-=====================================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2255378-inotifypropertychanged](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2255378-inotifypropertychanged)
-
-This is too specific an interface to bake in special knowledge for in the language. However, we recognize the pain of having to repeat the boilerplate around this, even as we've improved the situation here a bit with C# 6.
-
-We think that this may be better addressed with metaprogramming. While we don't have a clear story for how to support this better, in the language or compiler tool chain, we think that Roslyn in and of itself helps here.
-
-We'll keep watching the space and the specific scenario.
-
-
-
-4. GPU and DirectX support
-==========================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2730068-greatly-increase-support-for-gpu-programming-in-c](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2730068-greatly-increase-support-for-gpu-programming-in-c)
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3646222-enable-hlsl-directx-and-graphics-development-tool](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3646222-enable-hlsl-directx-and-graphics-development-tool)
-
-These are mostly library-level requests, independent of the language.
-
-One feature that could potentially improve such libraries would be the ability to specify generic constraints that somehow express the presence of numeric operators. Being able to write generic methods, say, over anything that has a `+` operator, allowing `+` to be used directly in that method body, would certainly improve the experience of writing such code, and would prevent a lot of repetition.
-
-Unfortunately, like other new constraints, such a numeric constraint facility would require new support from the CLR.
-
-
-
-5. Generalized extension members
-================================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2242236-allow-extension-properties](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2242236-allow-extension-properties)
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2060313-c-support-static-extension-methods-like-f](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2060313-c-support-static-extension-methods-like-f)
-
-The requests for extension properties and for static extension methods are essentially special cases of a general desire to be able to more generally specify extension member versions of all kinds of function members: properties, indexers, constructors, static members - why not?
-
-This is a reasonable request. The main problem we have is that the current scheme for extension methods doesn't easily generalize to other kinds of members. We'd need to make some very clever syntactic tricks to do this without it feeling like a complete replacement of the current syntax.
-
-This is certainly one that we will look at further for C# 7.
-
-
-
-6. More code analysis
-=====================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4428274-improve-code-analysis](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4428274-improve-code-analysis)
-
-This feels like it is best addressed via Roslyn-based analyzers.
-
-
-
-7. Extension methods in non-static classes
-==========================================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3359397-allow-extension-methods-to-be-defined-in-instance](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3359397-allow-extension-methods-to-be-defined-in-instance)
-
-We were very cautious when we first introduced extension methods, and surrounded them with a lot of restrictions. This is a well argued scenario where allowing them inside instantiable classes would enable a fluent style for private helper methods.
-
-This seems fair enough, and we could loosen this restriction, though it's probably a relatively low priority work item.
-
-
-
-8. XML comments
-===============
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2709987-xml-comments-schema-customization-in-c](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2709987-xml-comments-schema-customization-in-c)
-
-This is not a language suggestion.
-
-
-
-9. Unmanaged constraint
-=======================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4716089-unmanaged-generic-type-constraint-generic-pointe](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4716089-unmanaged-generic-type-constraint-generic-pointe)
-
-This would be great in order to enable pointers over type parameters. However, it requires CLR support.
-
-
-
-10. Compilable strings
-======================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/5592955-compliable-strings](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/5592955-compliable-strings)
-
-This is mostly addressed by `nameof` in C# 6; it's unlikely there is basis for more language level functionality here.
-
-
-
-11. Mulitple returns
-====================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2083753-return-multiple-values-from-functions-effortlessly](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2083753-return-multiple-values-from-functions-effortlessly)
-
-We're already looking at addressing this through tuples.
-
-
-
-12. ISupportInitialize
-======================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2094881-add-support-for-isupportinitialize-on-object-initi](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2094881-add-support-for-isupportinitialize-on-object-initi)
-
-This suggestion addresses the need to perform validation upon initialization. While depending on the ISupportInitialize interface is probably too specific, it is interesting to ponder if there is a way to e.g. hook in after an object initializer has run.
-
-
-
-13. ToNullable
-==============
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2531917-structure-all-nullable-values](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2531917-structure-all-nullable-values)
-
-This suggestion would add a new operator to make type parameters nullable only if they are not already so.
-
-You could certainly imagine something like this in conjunction with at least some variations of the nullability proposals we have been discussing lately.
-
-
-
-14. Statement lambdas in expression trees
-=========================================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4255391-let-lambdas-with-a-statement-body-be-converted-to](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4255391-let-lambdas-with-a-statement-body-be-converted-to)
-
-The language today doesn't allow statement lambdas to be converted to expression trees, despite there being expression tree classes for most features. Moreover, in fact, it disallows several expression forms, including `await` expressions.
-
-This would be a lovely gap to fill, especially since it would come with no conceptual overhead - more code would just work as expected. However, it is also an enormous feature to take on. We are not sure we have the weight of scenarios necessary to justify taking on the full magnitude of this.
-
-It is also possible that we'd address a subset.
-
-
-
-15. Language support for Lists, Dictionaries and Tuples
-=======================================================
-
-[http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2405699-build-list-dictionary-and-tuple-into-the-language](http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2405699-build-list-dictionary-and-tuple-into-the-language)
-
-We are already looking at tuples, and we do have it on our radar to consider language syntax for lists and dictionaries in some form. Many shapes of this feature would require a strong commitment to specific BCL types. However, you could also imagine having anonymous expression forms that target type to types that follow a given pattern.
diff --git a/docs/designNotes/2015-03-24 C# Design Meeting.md b/docs/designNotes/2015-03-24 C# Design Meeting.md
deleted file mode 100644
index 550e33845c0b5..0000000000000
--- a/docs/designNotes/2015-03-24 C# Design Meeting.md
+++ /dev/null
@@ -1,100 +0,0 @@
-C# Design Meeting Notes for Mar 24, 2015
-========================================
-
-Discussion thread on these notes is at https://github.com/dotnet/roslyn/issues/1898.
-
-*Quote of the Day:* If we have slicing we also need dicing!
-
-
-Agenda
-------
-
-In this meeting we went through a number of the performance and reliability features we have discussed, to get a better reading on which ones have legs. They end up falling roughly into three categories:
-
-* Green: interesting - let's keep looking
-* Yellow: there's something there but this is not it
-* Red: probably not
-
-As follows:
-
-1. ref returns and locals <*green*> (#118)
-2. readonly locals and parameters <*green*> (#115)
-3. Method contracts <*green*> (#119)
-4. Does not return <*green*> (#1226)
-5. Slicing <*green*> (#120)
-6. Lambda capture lists <*yellow - maybe attributes on lambdas*> (#117)
-7. Immutable types <*yellow in current form, but warrants more discussion*> (#159)
-8. Destructible types <*yellow - fixing deterministic disposal is interesting*> (#161)
-9. Move <*red*> (#160)
-10. Exception contracts <*red*>
-11. Static delegates <*red*>
-12. Safe fixed-size buffers in structs <*red*> (#126)
-
-Some of these were discussed again (see below), some we just reiterated our position.
-
-
-
-1. Ref returns and locals
-=========================
-
-At the implementation level these would require a verifier relaxation, which would cause problems when down targeting in sandboxing scenarios. This may be fine.
-
-At the language level, ref returns would have to be allowed on properties and indexers only if they do not have a setter. Setters and ref would be two alternative ways of allowing assignment through properties and indexers. For databinding scenarios we would need to check whether reflection would facilitate such assignment through a ref.
-
-A danger of ref returns in public APIs: say you return a ref into the underlying array of e.g. a list, and the list is grown by switching out the underlying array. Now someone can get a ref, modify the collection, follow the ref and get to the wrong place. So maybe ref returns are not a good thing on public API boundary.
-
-There's complexity around "safe to return": You should only return refs that you received as parameters, or got from the heap. This leads to complexity around allowing reassignment of ref locals: how do you track whether the ref they are pointing to is "safe to return" or not? We'd have to either
-
-* add syntax to declare which kind the local points to (complex)
-* allow only one of the kinds to be assigned to locals (restrictive)
-* track it as best we can through flow analysis (magic)
-
-There's complexity in how refs relate to readonly. You either can't take a ref to a readonly, or you need to be able to express a readonly ref through which assignments is illegal. The latter would need explicit representation in metadata, and ideally the verifier would enforce the difference.
-
-This can't very well be a C# only feature, at least if it shows up in public APIs. VB and F# would need to at least know about it.
-
-This feature would be a decent performance win for structs, but there aren't a lot of structs in the .NET ecosystem today. This is a chicken-and-egg thing: because structs need to be copied, they are often too expensive to use. So this feature could lower the cost of using structs, making them more attractive for their other benefits.
-
-Even so, we are still a bit concerned that the scenario is somewhat narrow for the complexity the feature adds. The proof will have to be in the use cases, and we're not entirely convinced about those. It would be wonderful to hear more from the community. This is also a great candidate for a prototype implementation, to allow folks to experiment with usability and performance.
-
-
-
-2. Readonly locals and parameters
-=================================
-
-At the core this is a nice and useful feature. The only beef we have with it is that you sort of want to use `readonly` to keep your code safe, and you sort of don't because you're cluttering your code. The `readonly` keyword simply feels a bit too long, and it would be nice to have abbreviations at least in some places.
-
-For instance `readonly var` could be abbreviated to `val` or `let`. Probably `val` reads better than `let` in many places, e.g. declaration expressions. We could also allow `val` as an abbreviation for `readonly` even in non-var situations.
-
-In Swift they use `let` but it reads strange in some contexts. In Swift it's optional in parameter positions, which helps, but we couldn't have that for back compat reasons.
-
-This is promising and we want to keep looking at it.
-
-
-
-4. Does Not Return
-==================
-
-It would be useful to be able to indicate that a method will never return successfully. It can throw or loop.
-
-The proposal is to do it as an attribute, but there would be more value if it was part of the type system. Essentially it replaces the return type, since nothing of that type is ever returned. We could call it `never`. The `never` type converts to pretty much anything.
-
-This would allow us to add throw *expressions* in the language - their type would be `never`.
-
-Having it in the type system allows e.g. returning `Task`, so that you can indicate an async method that will only ever produce an exception, if anything.
-
-Because of the Task example you do want to allow `never` in generics, but that means you could have generic types that unwittingly operate on never values, which is deeply strange. This needs to be thought about more.
-
-If through nasty tricks you get to a point in the code that according to never types should not be reachable, the code should probably throw.
-
-A common usage would be helper methods to throw exceptions. But throw as an expression is the most useful thing out of this.
-
-
-
-6. Attributes on lambdas
-========================
-
-Why? Guiding an analyzer, e.g. to prevent variable capture. Syntactically it might collide with XML literals in VB.
-
-We could probably hack it in. The attribute would be emitted onto the generated method.
-
diff --git a/docs/designNotes/2015-03-25 C# Design Meeting.md b/docs/designNotes/2015-03-25 C# Design Meeting.md
deleted file mode 100644
index 97547db186fc1..0000000000000
--- a/docs/designNotes/2015-03-25 C# Design Meeting.md
+++ /dev/null
@@ -1,169 +0,0 @@
-C# Design Meeting 2015-03-25
-============================
-
-Discussion thread for these notes can be found at https://github.com/dotnet/roslyn/issues/1572.
-
-These are notes that were part of a presentation on 2015-03-25 of a snapshot of our design discussions for C# 7 and VB 15. The features under discussion are described in detail in #206 and elsewhere.
-
-[Records](https://github.com/dotnet/roslyn/issues/206)
-=======
-
-Changes since Semih Okur's work:
-- Remove `record` modifier
-- `with` expressions (#5172)
-- Working on serialization
-
-Working proposal resembles Scala case classes with active patterns.
-
-------
-
-```cs
-class Point(int X, int Y);
-```
-
-- defines a class (struct) and common members
- - constructor
- - `readonly` properties
- - GetHashCode, Equals, ToString
- - operator== and operator!= (?)
- - Pattern-matching decomposition operator
-- an association between ctor parameters and properties
-- Any of these can be replaced by hand-written code
-- Ctor-parameter and property can have distinct names
-
-------
-
-### Use Cases
-- Simplifies common scenarios
-- Simple immutable user-defined data types
- - Roslyn Syntax Trees, bound nodes
-- Over-the-wire data
-- Multiple return values
-
-------
-
-### With expressions
-
-Illustrates an example of the value of having parameter-property association.
-
-Given
-
-```cs
-struct Point(int X, int Y);
-Point p = ...
-```
-
-the expression
-
-```cs
-p with { Y = 4 }
-```
-
-is translated to
-
-```cs
-new Point(p.X, 4)
-```
-
-------
-
-### Open issues
-- Closed hierarchy (and tag fields)
-- Readonly
-- Parameter names
-- Can you opt out of part of the machinery?
-- Serialization (in all of its forms)
-- Construction and decomposition syntax
-
-------
-
-[Pattern Matching](https://github.com/dotnet/roslyn/issues/206)
-================
-
-### Sources of Inspiration
-- Scala
-- F#
-- Swift
-- Rust
-- Erlang
-- Nemerle
-
-------
-
-### A pattern-matching operation
-- Matches a *value* with a *pattern*
-- Either *succeeds* or *fails*
-- Extracts selected values into *variables*
-
-```cs
- object x = ...;
- if (x is 3) ...
- if (x is string s) ...
- if (x is Point { X is 3, Y is int y }) ...
- if (x is Point(3, int y)) ...
-```
-
-------
-
-### Other aspects
-- Patterns defined recursively
-- "select" from among a set of pattern forms
-- Typically an expression form
-- *active patterns* support interop and user-defined types
-
-```cs
-switch (o)
-{
- case 3:
- ...
- break;
- case string s:
- M(s);
- break;
- case Point(3, int y):
- M(y);
- break;
- case Point(int x, 4):
- M(x);
- break;
-}
-```
-
-We think we want an expression form too (no proposed syntax yet, but for inspiration):
-
-```cs
- M(match(e) {
- 3 => x,
- string s => s.foo,
- Point(3, int y) => y,
- * => null })
-```
-
-------
-
-### Benefits
-- Condenses long sequences of complex logic with a test that resembles the shape of the thing tested
-
-### Use Cases
-- Simplifies common scenarios
-- Language manipulation code
- - Roslyn
- - Analyzers
-- Protocol across a wire
-
-------
-
-### Open questions
-- How much of the pattern-matching experience do we want (if any)?
-- Matching may be compiler-checked for completeness
-- May be implemented using tags instead of type tests
-- Which types have syntactic support?
- - Primitives and string
- - Records
- - Nullable
- - objects with properties
- - anonymous types?
- - arrays?
- - List? Dictionary?
- - Tuple<...>?
- - IEnumerable?
diff --git a/docs/designNotes/2015-03-25 C# Design Review.md b/docs/designNotes/2015-03-25 C# Design Review.md
deleted file mode 100644
index fd5039465ca24..0000000000000
--- a/docs/designNotes/2015-03-25 C# Design Review.md
+++ /dev/null
@@ -1,173 +0,0 @@
-C# Language Design Review, Mar 25, 2015
-=======================================
-
-Discussion thread for these notes can be found at https://github.com/dotnet/roslyn/issues/1921.
-
-We've recently changed gears a little on the C# design team. In order to keep a high design velocity, part of the design team meets one or two times each week to do detailed design work. Roughly monthly the full design team gets together to review and discuss the direction. This was the first such review.
-
-
-Agenda
-------
-
-1. Overall direction
-2. Nullability features
-3. Performance and reliability features
-4. Tuples
-5. Records
-6. Pattern matching
-1. Overall direction
-====================
-
-In these first two months of design on C# 7 we've adopted a mix of deep dive and breadth scouring. There's agreement that we should be ambitious and try to solve hard problems, being willing to throw the result away if it's not up to snuff. We should keep an open mind for a while still, and not lock down too soon on a specific feature set or specific designs.
-
-
-
-2. Nullability features
-=======================
-
-Non-nullable types are the number one request on UserVoice. We take it that the *underlying problem* is trying to avoid null reference exceptions. Non-nullable types are at best only part of the solution to this. We'd also need to help prevent access when something is *nullable*.
-
-We've looked at this over a couple of design meetings (#1303, #1648). Ideally we could introduce non-null types, such as `string!` that are guaranteed never to be null. However, the problems around initialization of fields and arrays, etc., simply run too deep. We can never get to full guarantees.
-
-We've been mostly looking at implementation approaches that use type erasure, and that seems like a promising approach.
-
-However, the thing we need to focus on more is this: when you get a nullability warning from this new feature, how do you satisfy the compiler? If you need to use unfamiliar new language features or significant extra syntax to do so, it probably detracts from the feature.
-
-Instead we should at least consider an flow-based approach, where the "null-state" of a variable is tracked based on tests, assignments etc.
-
-``` c#
-if (x == null) return;
-// not null here
-```
-
-It's an open question how far we would go. Would we track only locals and parameters, or would we also keep track of fields?
-
-``` c#
-if (foo.x == null) ...
-```
-
-This is more problematic, not just because of the risk of other threads changing the field, but also because other code may have side effects on the field or property.
-
-TypeScript uses information about type guards to track union types in if branches, but it's not full flow analysis, and works only for local variables. Google Closure is more heuristics based, and is happy to track e.g. `foo.bar.baz` style patterns.
-
-A core nuisance with nullability checking is that it raises a wealth of compat questions that limit the design in different ways. There may need to be some sort of opt-in to at least some of the diagnostics you'd get, since you wouldn't want them if you were just recompiling old code that used to "work".
-
-
-
-3. Performance and reliability
-==============================
-
-The list produced at a recent design meeting (#1898) looks sensible.
-
-val / readonly
---------------
-
-We should cross check with Scala on their syntax.
-
-
-ref return / locals
--------------------
-
-Lots of compexitity - we question whether it is worth the cost?
-
-
-Never type
-----------
-
-The type system approach is interesting, and allows throw expressions.
-
-Method contracts
-----------------
-
-`requires` / `ensures`, show up in docs, etc. This looks great. The biggest question is what happens on failure: exceptions? fail fast?
-
-
-Slices
-------
-
-We got strong feedback that array slices are only interesting if we unify them with arrays. Otherwise there's yet another bifurcation of the world. There's *some* value to have a `Slice` struct type just show up in the Framework. But it really doesn't seem worth it unless it's a runtime feature. That unification is really hard to achieve, and would require CLR support. It's valuable enough to try to pursue even with high likelihood of failure.
-
-Slicing as a language syntax could also be "overloadable" - on IEnumerables for instance.
-
-In Go, if you treat a slice as an object, it gets boxed.
-
-
-Lambda capture lists
---------------------
-
-Not interesting as a feature, but the idea of allowing attributes on lambdas might fly.
-
-
-Immutable types
----------------
-
-General concern that this doesn't go far enough, is lying to folks, etc. It tries to have strong guarantees that we can't make.
-
-But a lot of people would appreciate *something* here, so the scenario of immutability should continue to motivate us.
-
-
-Destructible types
-------------------
-
-The scenario is good, not the current proposal.
-
-
-
-4. Tuple types
-==============
-
-There's agreement on wanting the feature and on the syntax (#347, #1207).
-
-We probably prefer a value type version of Tuple. Of course those would be subject to tearing, like all structs. We're willing to be swayed.
-
-There are performance trade offs around allocation vs copying, and also around generic instantiation. We could do some experiments in F# source code, which already has tuples.
-
-
-
-5. Records
-==========
-
-See #180, #206, #396, #1303, #1572.
-
-In the current proposal, we should just give up on the ability to name constructor parameters and members differently. The motivation was to be able to upgrade where parameter names start with lower case and member names upper case, but it's not worth the complexity.
-
-Should it have `==` and `!=` that are value based? Clashes a little with the ability to make them mutable.
-
-If I introduce extra state, then I have to write my own GetHashCode. That seems unfortunate.
-
-All the gunk today is part of why Roslyn uses XML to generate its data structure. A test of success would be for the Roslyn syntax trees to be concise to write in source code.
-
-A big issue here is incremental non-destructive modification. Roslyn follows the pattern of "Withers", a method for each property that takes a new value for that property and returns a new object that's a copy of the old one except for that property. Withers are painfully verbose to declare, and ideally this feature would offer a solution to that.
-
-Serialization has to work *somehow*, even though many of the members will be generated.
-
-We should not be *too* concerned about the ability to grow up to represent all kinds of things. Start from it being the POD feature, and work from there.
-
-
-
-6. Pattern matching
-===================
-
-See #180, #206, #1572.
-
-Whether introduced variables are mutable or not is not a key question: we can go with language uniformity or scenario expectation.
-
-Integral value matching is an opportunity to generalize. The pattern 3 may match the value 3 of all integral types rather than just the int 3.
-
-Named matching against all objects and positional against ones that define a positional match. Are recursive patterns necessary? No, but probably convenient and there's no reason not to have them.
-
-Pattern matching could be shoe-horned into current `switch` statements as well as `is` expressions. And we could have a switching *expression* syntax as well:
-
-``` c#
-var x = match(e) { p => e, p => e, * => e }
-```
-An expression version would need to be checked by the compiler for completeness. A little clunky, but much more concise than using a switch.
-
-Similar to a current pattern in the Roslyn code base:
-
-``` c#
-Match(Func f1, Func f2) { ... }
-var x = Match((string s) => e, (int i) => e);
-```
-
-Maybe the fat arrow is not right. We need to decide on syntax. Another option is to use the case keyword instead.
diff --git a/docs/designNotes/2015-04-01,8 C# Design Meeting.md b/docs/designNotes/2015-04-01,8 C# Design Meeting.md
deleted file mode 100644
index edffd967a6930..0000000000000
--- a/docs/designNotes/2015-04-01,8 C# Design Meeting.md
+++ /dev/null
@@ -1,138 +0,0 @@
-C# Design Meeting Notes for Apr 1 and Apr 8, 2015
-=================================================
-
-Discussion thread for these notes is at https://github.com/dotnet/roslyn/issues/2119.
-
-Agenda
-------
-
-Matt Warren wrote a Roslyn analyzer as a low cost way to experiment with nullability semantics. In these two meetings we looked at evolving versions of this analyzer, and what they imply for language design.
-
-The analyzer is here: https://github.com/mattwar/nullaby.
-
-
-
-Flow-based nullability checking
-===============================
-
-At the design review on Mar 25 (#1921), there was strong support for adding nullability support to the language, but also the advice to make it easy to transition into using nullability checking by recognizing current patterns for null checking.
-
-This suggests a flow-based approach, where the "null state" of variables is tracked by the compiler, and may be different in different blocks of code. Comparisons of the variable, and assignments to the variable, would all change its null state within the scope of effect of those operations.
-
-An inherent danger with flow-based checks like that is that a variable may change in an untracked way. The risk of that for parameters and local variables is limited: the variable would have to be captured and modified by a lambda, and that lambda would have to be executed elsewhere *during* the running of the current function. Given that any null-checking machinery we build would have to be somewhat approximate anyway, we can probably live with this risk.
-
-It gets gradually worse if we try to track fields of `this` or other objects, or even properties or array elements. In all likelihood, tracking just parameters and local variables would deliver the bulk of the value, but at least "dotted chains" would certainly also be useful.
-
-
-
-Attributes versus syntax
-========================
-
-The analyzer makes use of attributes to denote when a variable is "nullable" (`[CouldBeNull]`) or "non-nullable" (`[ShouldNotBeNull]`). Compared to a built-in syntax, this has several disadvantages:
-
-* It's less syntactic convenient of course
-* The attribute cannot be applied to local variables
-* The attribute cannot be applied to a type argument or an array element type
-
-These limitations are inherent to the nature of the experiment, but we know how to counter them if we add language syntax, even if that syntax is encoded with the use of attributes. (We learned all the tricks when we introduced `dynamic`.)
-
-
-
-Analyzers versus built-in rules
-===============================
-
-Providing nullability diagnostics by means of an analyzer comes with a number of pros and cons compared to having those diagnostics built in to the language.
-
-* Language rules need to be clearly specified and reasonable to explain. An analyzer can employ more heuristics.
-* Language-based diagnostics need to consider back compat for the language, whereas analyzers can introduce warnings on currently valid code.
-* For the same reason, analyzers can evolve over time
-* With an analyzer, individual rules can be turned on and off. Some may want a harsher medicine than others. With the language it has to be one size fits all.
-
-On the other hand:
-
-* Rules can probably be implemented more efficiently in the compiler itself (though we might be able to come up with tricks to deal with that for analyzers too)
-* The language has an opportunity to standardize what exactly is allowed
-* The rules would still apply in contexts where analyzers aren't run
-* It would be odd to add `!` and `?` syntax to the language, without adding the accompanying semantics
-* We could avoid many issues with back compat if we adopt the notion of "warning waves" (#1580), where later versions of the language can add new warnings.
-
-The analyzer has several shortcomings due to the lack of a public flow analysis API in Roslyn. That would be a great addition, regardless of what we do for nullability checking.
-
-With a cruder/simpler analysis built-in to the language, you can imagine folks building enhancement analyzers on top of it. Those may not just add new diagnostics, but might want to *turn off* compiler warnings where more heuristics can determine that they are in fact not warranted. The analyzer infrastructure doesn't currently support this.
-
-
-
-Taking the analyzer for a spin
-==============================
-
-Given the following declaration
-
-``` c#
-void Foo([ShouldNotBeNull] string s) { }
-```
-
-The following statements would yield warnings because `s` is declared to be nullable, but is used in a way that requires it not to be:
-
-``` c#
-void Bad([CouldBeNull] string s)
-{
- Foo(s); // Warning!
- var l = s.Length; // Warning!
-}
-```
-
-However, all the following methods are ok, because the flow analysis can determine that `s` is not null at the point where it is used:
-
-``` c#
-void Ok1([CouldBeNull] string s)
-{
- s = "Not null";
- Foo(s); // Ok
-}
-void Ok2([CouldBeNull] string s)
-{
- if (s != null)
- {
- Foo(s); // Ok
- }
-}
-void Ok3([CouldBeNull] string s)
-{
- if (s == null)
- {
- throw new ArgumentNullException();
- }
- Foo(s); // Ok
-}
-void Ok4([CouldBeNull] string s)
-{
- if (s == null)
- {
- s = "NotNull";
- }
- Foo(s); // Ok
-}
-void Ok5([CouldBeNull] string s)
-{
- if (s != null && s.Length > 0) // Ok
- {
- }
-}
-void Ok6([CouldBeNull] string s)
-{
- if (s == null || s.Length > 0) // Ok
- {
- }
-}
-```
-
-This seems hugely useful, because current code will just continue to work in the vast majority of cases.
-
-It is a change of thinking from where nullability is strongly part of the *type* of a variable, and is established at declaration time. In that paradigm, establishing that a given variable is not null doesn't help you; you have to capture its value in a new, more strongly typed variable, which is more cumbersome, and which would require existing code to be extensively rewritten to match new patterns.
-
-
-
-Conclusion
-==========
-
-Matt's experiment is great, and we are very interested in the nullability tracking approach, because it has the potential to make the bulk of existing code work in the face of new annotations.
diff --git a/docs/designNotes/2015-04-14 C# Design Meeting.md b/docs/designNotes/2015-04-14 C# Design Meeting.md
deleted file mode 100644
index 11b8c1c14e39d..0000000000000
--- a/docs/designNotes/2015-04-14 C# Design Meeting.md
+++ /dev/null
@@ -1,86 +0,0 @@
-C# Design Meeting Notes for Apr 14
-==================================
-
-Discussion thread for these notes can be found at https://github.com/dotnet/roslyn/issues/2134.
-
-Bart De Smet visited from the Bing team to discuss their use of Expression Trees, and in particular the consequences of their current shortcomings.
-
-The Expression Tree API today is not able to represent all language features, and the language supports lambda conversions even for a smaller subset than that.
-
-
-
-Background
-==========
-
-Certain Bing services, such as parts of Cortana, rely on shipping queries between different machines, both servers in the cloud and client devices.
-
-In a typical scenario a lambda expression tree is produced in one place, ideally via the conversion from lambda expressions to expression trees that exists in C#. The expression tree is then serialized using a custom serialization format, and sent over the wire. At the receiving end it will often be stitched into a larger expression tree, which is then compiled with the `Compile` method and executed.
-
-Along the way, several transformations are often made on the trees, for efficiency reasons etc. For instance, rather than invoke a lambda its body can often be inlined in the enclosing tree that the lambda gets stitched into.
-
-The serialization format is able to carry very specific type information along with the code, but can also represent the code loosely. A looser coupling makes for code that is more resilient to "schema" differences between the nodes, and also allows for use of types and functions that aren't present where the lambda is concocted. However, it also makes it harder to stich things back up right on the other side.
-
-
-
-Shortcomings in the Expression Tree API
-=======================================
-
-The expression tree API was introduced with Linq and C# 3.0, and was extended to support the implementation infrastructure of `dynamic` along with C# 4.0. However, it has not been kept up to date with newer language features.
-
-This is a list of ones that are confounding to the Bing team.
-
-
-Dynamic
--------
-
-Even though the API was extended for the benefit of the dynamic feature, the feature itself ironically is not well represented in the API. This is not a trivial undertaking: in Expression Trees today, all invoked members are represented using reflection structures such as `MemberInfo`s etc. Dynamic invocations would need a completely different representation, since they are by definition not bound by the time the expression tree is produced.
-
-In the Bing scenario, dynamic would probably help a lot with representing the loosely coupled invocations that the serialization format is able to represent.
-
-Alternatively, if the C# language added something along the "lightweight dynamic" lines that were discussed (but ultimately abandoned) for C# 6, the representation of that in Expression Trees would probably yield similar benefit with a fraction of the infrastructure.
-
-
-Await
------
-
-Representing await would probably be easy in the Expression Tree API. However, the implementation of it in `Expression.Compile` would be just as complex as it is in the C# and VB compilers today. So again, this is a significant investment, though one with much less public surface area complexity than `dynamic`.
-
-Needless to say, distributed scenarios such as that of Bing services have a lot of use for `await`, and it can be pretty painful to get along without it.
-
-
-Null conditional operators and string interpolation
----------------------------------------------------
-
-These should also be added as Expression Tree nodes, but could probably be represented as reducible nodes. Reducible nodes are a mechanism for describing the semantics of a node in terms of reduction to another expression tree, so that the `Compile` method or other consumers don't have to know about it directly.
-
-
-Higher level statements
------------------------
-
-While expression trees have support for statements, those tend to be pretty low level. Though there is a `loop` node there are no `for` or `foreach` nodes. If added, those again could be reducible nodes.
-
-
-
-Shortcomings in the languages
-=============================
-
-C# and VB are even more limited in which lambdas can be converted to expression trees. While statements are part of the Expression Tree API, the languages will not convert them. Also, assignment operators will not be converted.
-
-This is a remnant of the first wave of Linq, which focused on allowing lambdas for simple, declarative queries, that could be translated to SQL.
-
-There has traditionally been an argument against adding more support to the languages based on the pressure this would put on existing Linq providers to support the new nodes that would start coming from Linq queries in C# and VB.
-
-This may or may not ever have been a very good argument. However, with Roslyn analyzers now in the world, it pretty much evaporates. Any Linq provider that wants to limit at design time the kinds of lambdas allowed, can write a diagnostic analyzer to check this, and ship it with their library.
-
-None of this support would require new syntax in the language, obviously. It is merely a matter of giving fewer errors when lambdas are converted to expression trees, and of mapping the additional features to the corresponding nodes in what is probably a straightforward fashion.
-
-
-
-Conclusion
-==========
-
-There is no remaining design reason we can think of why we shouldn't a) bring the Expression Tree API up to date with the current state of the languages, and b) extend the language support accordingly.
-
-The main issue here is simply that it is likely to be a huge undertaking. We are not sure that the sum of the scenarios will warrant it, when you think about the opportunity cost for other language evolution. Bing is a very important user, but also quite probably an atypical one.
-
-So in summary, as a language design team, we certainly support completing the picture here. But with respect to priorities, we'd need to see a broader call for these improvements before putting them ahead of other things.
diff --git a/docs/designNotes/2015-04-15 C# Design Meeting.md b/docs/designNotes/2015-04-15 C# Design Meeting.md
deleted file mode 100644
index b0576d5e65f8b..0000000000000
--- a/docs/designNotes/2015-04-15 C# Design Meeting.md
+++ /dev/null
@@ -1,72 +0,0 @@
-C# Design Meeting Notes for Apr 15
-==================================
-
-Discussion thread for these notes is at https://github.com/dotnet/roslyn/issues/2133.
-
-Agenda
-------
-
-In this meeting we looked at nullability and generics. So far we have more challenges than solutions, and while we visited some of them, we don't have an overall approach worked out yet.
-
-1. Unconstrained generics
-2. Overriding annotations
-3. FirstOrDefault
-4. TryGet
-
-
-Unconstrained generics
-======================
-
-Fitting generics and nullability together is a delicate business. Let's look at unconstrained type parameters as they are today. One the one hand they allow access to members that are on all objects - `ToString()` and so on - which is bad for nullable type arguments. On the other hand they allow `default(T)` which is bad for non-nullable type arguments.
-
-Nevertheless it seems draconian to not allow instantiations of unconstrained type parameters with, say, `string?` and `string!`. We suspect that most generic types and methods probably behave pretty nicely in practice.
-
-For instance, `List`, `Dictionary` etc. would certainly have internal data structures - arrays - that would have the default value in several places. However, their logic would be written so that no array element that hadn't explicitly been assigned a value from the user would ever expose its default value later. So if we look at a `List` we wouldn't actually ever see nulls come out as a result of the internal array having leftover nulls from its initial allocation. No nulls would come in, and therefore no nulls would come out. We want to allow this.
-
-
-Overriding annotations
-======================
-
-When type parameters are known to be reference types it may make sense to allow overriding of the nullability of the type parameter: `T?` would mean `sting?` regardless of whether the type argument was `string!`, `string` or `string?`.
-
-This would probably help in some scenarios, but with most generics the type parameter isn't actually known to be a reference type.
-
-
-FirstOrDefault
-==============
-
-This pattern explicitly returns a default value if the operation fails to find an actual value to return. Obviously that is unfortunate if the element type is non-nullable - you'd still get a null out!
-
-In practice, such methods tend to be so glaringly named (precisely because their behavior is a little funky) that most callers would probably already be wary of the danger. However, we might be able to do a little better.
-
-What if there was some annotation you could put on `T` to get the nullable version *if* `T` should happen to be a reference type. Maybe the situation is rare enough for this to just be an attribute, say `[NullableIfReference]`:
-
-``` c#
-public [return:NullableIfReference] T FirstOrDefault(this IEnumerable src)
-{
- if ...
- else return default(T);
-}
-```
-
-Applied to `List` (or `List`) this would return a `string?`. But applied to `List` it would return an `int` not an `int?`.
-
-This seems perfectly doable, but may not be worth the added complexity.
-
-
-TryGet
-======
-
-This pattern has a bool return value signaling whether a value was there, and an out parameter for the result, which is explicitly supposed to be default(T) when there was no value to get:
-
-``` c#
-public bool TryGet(out T result) { ... }
-```
-
-Of course no-one is expected to ever look at the out parameter if the method returns false, but even so it might be nice to do something about it.
-
-This is not a situation where we want to apply the `[NullableIfReference]` attribute from above. The consumer wants to be able to access the result without checking for null if they have already checked the returned bool!
-
-We could imagine another attribute, `[NullableIfFalse]` that would tell the compiler at the consuming site to track nullability based on what was returned from the method, just as if there had been a null check directly in the code.
-
-Again, this might not be worth the trouble but is probably doable.
diff --git a/docs/designNotes/2015-04-22 C# Design Review.md b/docs/designNotes/2015-04-22 C# Design Review.md
deleted file mode 100644
index fc9b7a194730a..0000000000000
--- a/docs/designNotes/2015-04-22 C# Design Review.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# C# Language Design Review, Apr 22, 2015
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/3910.
-
-## Agenda
-
-See #1921 for an explanation of design reviews and how they differ from design meetings.
-
-1. Expression tree extension
-2. Nullable reference types
-3. Facilitating wire formats
-4. Bucketing
-
-
-# Expression Trees
-
-Expression trees are currently lagging behind the languages in terms of expressiveness. A full scale upgrade seems like an incredibly big investment, and doesn't seem worth the effort. For instance, implementing `dynamic` and `async` faithfully in expression trees would be daunting.
-
-However, supporting `?.` and string interpolation seems doable even without introducing new kinds of nodes in the expression tree library. We should consider making this work.
-
-
-# Nullable reference types
-
-A big question facing us is the "two-type" versus the "three-type" approach: We want you to guard member access etc. behind null checks when values are meant to be null, and to prevent you from sticking or leaving null in variables that are not meant to be null. In the "three-type" approach, both "meant to be null" and "not meant to be null" are expressed as new type annotations (`T?` and `T!` respectively) and the existing syntax (`T`) takes on a legacy "unsafe" status. This is great for compatibility, but means that the existing syntax is unhelpful, and you'd only get full benefit of the nullability checking by completely rooting out its use and putting annotations everywhere.
-
-The "two-type" approach still adds "meant to be null" annotations (`T?`), but holds that since you can now express when things *are* meant to be null, you should only use the existing syntax (`T`) when things are *not* meant to be null. This certainly leads to a simpler end result, and also means that you get full benefit of the feature immediately in the form of warnings on all existing unsafe null behavior! Therein of course also lies the problem with the "two-type" approach: in its simplest form it changes the meaning of unannotated `T` in a massively breaking way.
-
-We think that the "three-type" approach is not very helpful, leads to massively rewritten over-adorned code, and is essentially not viable. The "two-type" approach seems desirable if there is an explicit step to opt in to the enforcement of "not meant to be null" on ordinary reference types. You can continue to use C# as it is, and you can even start to add `?` to types to force null checks. Then when you feel ready you can switch on the additional checks to prevent null from making it into reference types without '?'. This may lead to warnings that you can then either fix by adding further `?`s or by putting non-null values into the given variable, depending on your intent.
-
-There are additional compatibility questions around evolution of libraries, but those are somewhat orthogonal: Maybe a library carries an assembly-level attribute saying it has "opted in", and that its unannotated types should be considered non-null.
-
-There are still open design questions around generics and library compat.
-
-
-# Wire formats
-
-We should focus attention on making it easier to work with wire formats such as JSON, and in particular on how to support strongly typed logic over them without forcing them to be deserialized to strongly typed objects at runtime. Such deserialization is brittle, lossy and clunky as formats evolve out of sync, and extra members e.g. aren't kept and reserialized on the other end.
-
-There's a range of directions we could take here. Assuming there are dictionary-style objects representing the JSON (or other wire data) in a weakly typed way, options include:
-
-* Somehow supporting runtime conversions from such dictionaries to interfaces (and back)
-* Compile-time only "types" a la TypeScript, which translate member access etc. to a well-known dictionary pattern
-* Compile-time type providers a la F#, that allow custom specification not only of the compile-time types but also the code generated for access.
-
-We'd need to think about construction, not just consumption.
-
-``` c#
-var thing = new Thing { name = "...", price = 123.45 }
-```
-
-Maybe `Thing` is an interface with an attribute on it:
-
-``` c#
-[Json] interface { string name; double price; }
-```
-
-Or maybe it is something else. This warrants further exploration; the right feature design here could be an extremely valuable tool for developers talking to wire formats - and who isn't?
-
-# Bucketing
-
-We affirmed that the bucketing in issue #2136 reflects our priorities.
\ No newline at end of file
diff --git a/docs/designNotes/2015-05-20 C# Design Meeting.md b/docs/designNotes/2015-05-20 C# Design Meeting.md
deleted file mode 100644
index 163504bc36381..0000000000000
--- a/docs/designNotes/2015-05-20 C# Design Meeting.md
+++ /dev/null
@@ -1,261 +0,0 @@
-C# Design Meeting Notes for May 20
-==================================
-
-Discussion for this issue can be found at https://github.com/dotnet/roslyn/issues/3911.
-
-_Quote of the day:_ The slippery slope you are talking about is that if we satisfy our customers they'll want us to satisfy them some more.
-
-
-Agenda
-------
-
-Today we discussed whether and how to add local functions to C#, with the aim of prototyping the feature in the near future. Proposal at issue #259. Some details are discussed in issue #2930.
-
-1. Local functions
-
-
-
-Local Functions
-===============
-
-We agree that the scenario is useful. You want a helper function. You are only using it from within a single function, and it likely uses variables and type parameters that are in scope in that containing function. On the other hand, unlike a lambda you don't need it as a first class object, so you don't care to give it a delegate type and allocate an actual delegate object. Also you may want it to be recursive or generic, or to implement it as an iterator.
-
-
-Lambdas or local functions?
----------------------------
-
-There are two ways of approaching it:
-
-* Make lambdas work for this
-* Add local function syntax to the language
-
-On the face of it, this seems like it would be better to reuse an existing feature. After all, we are not looking to address a new problem but just make existing code more convenient to write. In VB this scenario works pretty nicely with lambdas already - can't we just take a page out of VB's book?
-
-Well, it turns out you need a plethora of little features to achieve the full effect with lambdas:
-
-* lambdas would need to have an intrinsic (compiler-generated) delegate type that we can infer for them when they are not target typed to a specific delegate type:
-
-``` c#
-var f = (int x) => x * x; // infers a compiler generated delegate type for int -> int.
-```
-
-* lambdas need to be able to recursively call themselves through a variable name they get assigned to. This introduces a problem with inferring a return type:
-
-``` c#
-var f = (int x, int c) => c = 0 ? x : f(x) * x; // can we reasonably infer a return type here?
-var f = (int x, int c) => (int)(c = 0 ? x : f(x) * x); // or do we need to cast the result?
-```
-
-* lambdas need to be able to be iterators. Since they don't have a specified return type, how can we know if the iterator is supposed to be `IEnumerable`, `IEnumerator`, `IEnumerable` or `IEnumerator`?
-
-``` c#
-var f = (int x, int c) => { for (int i = 0; i < c; i++) { yield return x; } }; // default to IEnumerable?
-```
-
-* We'd want lambdas to be generic. What's the syntax for a generic lambda - where do the type parameters go? Presumably in front of the parameter list? And wait a minute, we don't even have a notion of delegate types for generic functions!
-
-``` c#
-var f = (IEnumerable src) => src.FirstOrDefault(); // Is this unambiguous? What's the delegate type?
-```
-
-VB does a subset of these, probably enough to get by, but all in all for C# it seems both the better and easier path to simply let you define a function in method scope.
-
-On top of this is the performance aspect: the lambda approach implies a lot of allocations: one for the delegate and one for the closure object to capture surrounding variables and type parameters.
-
-Sometimes one or both of these can be optimized away by a clever compiler. But with functions, the delegate is never there (unless you explicitly decide to create one when you need it), and if the function itself is not captured as a delegate, the closure can be a struct on the stack.
-
-**Conclusion**: Local functions are the better choice. Let's try to design them.
-
-
-Syntax
-------
-
-The syntax of a local functions is exactly as with a method, except that it doesn't allow the syntactic elements that are concerned with it being a member. More specifically:
-
-* No attributes
-* No modifiers except `async` and `unsafe`
-* The name is always just an identifier (not `Interface.MemberName`)
-* The body is never just `;` (always `=> ...` or `{ ... }`)
-
-We'll consider *local-function-declaration* to be a third kind of *declaration-statement*, next to *local-variable-declaration* and *local-constant-declaration*. Thus it can appear as a statement at the top level of a block, but cannot in itself be e.g. a branch of an if statement or the body of a while statement.
-
-Local functions need to be reconciled with top level functions in script syntax, so that they work as similarly as possible. Nested local functions in blocks, just like nested local variables, would truly be local functions even in script.
-
-
-Examples
---------
-
-A classical example is that of doing argument validation in an iterator function. Because the body of an iterator method is executed lazily, a wrapper function needs to do the argument checking. The actual iterator function can now be a local function, and capture all the arguments to the wrapper function:
-
-``` c#
-public static IEnumerable Filter(IEnumerable source, Func predicate)
-{
- if (source == null) throw new ArgumentNullException(nameof(source));
- if (predicate == null) throw new ArgumentNullException(nameof(predicate));
-
- IEnumerable Iterator()
- {
- foreach (var element in source)
- if (predicate(element))
- yield return element;
- }
- return Iterator();
-}
-
-```
-
-An example of a recursive local function would be a Quicksort, for instance:
-
-``` c#
-public static void Quicksort(T[] elements) where T : IComparable
-{
- void Sort(int start, int end)
- {
- int i = start, j = end;
- var pivot = elements[(start + end) / 2];
-
- while (i <= j)
- {
- while (elements[i].CompareTo(pivot) < 0) i++;
- while (elements[j].CompareTo(pivot) > 0) j--;
- if (i <= j)
- {
- T tmp = elements[i];
- elements[i] = elements[j];
- elements[j] = tmp;
- i++;
- j--;
- }
- }
- if (start < j) Sort(elements, start, j);
- if (i < end) Sort(elements, i, end);
- }
-
- Sort(elements, 0, elements.Length - 1);
-}
-```
-
-Again it captures parameters and type parameters of the enclosing method, while calling itself recursively.
-
-For optimization purposes, some async methods are implemented with a "fast path" where they don't allocate a state machine or a resulting `Task` unless they discover that it's necessary. These aren't themselves `async`, but can have a nested local async function that they call when necessary, returning the resulting `Task`. Something along the lines of:
-
-``` c#
-public Task GetByteAsync()
-{
- async Task ActuallyGetByteAsync()
- {
- await buffer.GetMoreBytesAsync();
- byte result;
- if (!buffer.TryGetBufferedByte(out result)) throw ...; // we just got more
- return result;
- }
-
- byte result;
- if (!buffer.TryGetBufferedByte(out result)) return ActuallyGetByteAsync(); // slow path
-
- if (taskCache[result] == null) taskCache[result] = Task.FromResult(result);
- return taskCache[result];
-}
-```
-
-By the way, we just did `taskCache[result]` three times there in the last two lines, each with its own bounds check. We could maybe optimize a little with a local function taking a ref:
-
-``` c#
- Task GetTask(ref Task cache)
- {
- if (cache == null) cache = Task.FromResult(result);
- return cache;
- }
- return GetTask(ref taskCache[result]); // only indexing once
-```
-
-Of course if we *also* add ref locals to the language, such trickery would not be necessary.
-
-
-Scope and overloading
----------------------
-
-In various ways we need to choose whether local functions are more like methods or more like local variables:
-
-* Local variables only allow one of a given name, whereas methods can be overloaded
-* Local variables shadow anything of the same name in outer scopes, whereas method lookup will keep looking for applicable methods
-* Local variables are not visible (it is an error to use them) before their declaration occurs, whereas methods are.
-
-There are probably scenarios where it would be useful to overload local functions (or at least more elegant not to have to give them all separate names). You can also imagine wanting to augment a set of existing overloads with a few local ones.
-
-However, it is somewhat problematic to allow local functions to be visible before their declaration: they can capture local variables, and it would provide an easy loophole for manipulating those variables before their declaration:
-
-``` c#
-f(3);
-int x; // x is now 3!
-void f(int v) { x = v; }
-```
-
-Such pre-declaration manipulation is certainly possible today, but it requires more sneaky use of lambdas or goto statements, e.g.:
-
-``` c#
- goto Assign;
-Before:
- goto Read;
-Declare:
- int x = 5;
- goto Read;
-Assign:
- x = 3;
- goto Before;
-Read:
- WriteLine(x);
- if (x == 3) goto Declare;
-```
-
-This prints 3 and 5. Yeah, yuck. We should think twice before we allow local functions to make this kind of thing so much easier that you might likely do it by mistake.
-
-On the other hand, there's no nice way to write mutually recursive local functions, unless the first can also see the second. (The workaround would be to nest one within the other, but that's horrible).
-
-For now, for prototyping purposes, we'll say that local functions are more like local variables: there can only be one of a given name, it shadows same-named things in outer scopes, and it cannot be called from a source location that precedes its declaration. We can consider loosening this later.
-
-Definite assignment analysis of locals captured by local functions should be similar to lambdas for now. We can think of refining it later.
-
-
-Type inference
---------------
-
-Lambdas have a mechanism for inferring their return type. It is used for instance when a lambda is passed to a generic method, as part of that generic method's type inference algorithm.
-
-We could allow local functions to be declared with `var` as their return type. Just as `var` on local variables doesn't always succeed, we could fail whenever finding the return type of the local function is too hard; e.g. if it is recursive or an iterator.
-
-``` c#
-var fullName(Person p) => $"{p.First} {p.Last}"; // yeah, it's probably going to be a string.
-```
-
-We don't need this for prototyping, but it is nice to consider for the final design of the feature.
-
-
-Declaration expressions
------------------------
-
-One thing lambdas have going for them is that they can be embedded in expression contexts, whereas local declarations currently can't, though we had a proposal for declaration expressions in C# 6. If we were to do some sort of let expressions, local functions should ideally work alongside local variables. The proposed C# 6 scheme would work for that:
-
-``` c#
-return (IEnumerable Impl() { ... yield return ... }; Impl()); // Or no semicolon?
-```
-
-Why would you do that? For encapsulation, but especially if you're in a big expression context where pulling it out is too far. Imagine a string-interpolated JSON literal that has an array inside it that I want to construct with an iterator:
-
-``` c#
-return $@"""hello"": ""world""
- ... // 30 lines of other stuff
- ""list"" : { (
- IEnumerable GetValues() {
- ... yield return ...
- };
- JsonConvert.SerializeObject(GetValues())) }";
-```
-
-We don't have to think about this now, but it is nice to know that it's possible if we ever do declaration expressions to include local functions as one of the things you can declare in an expression context.
-
-
-Slippery slope
---------------
-
-Local classes might be the next ask, but we perceive them as much less frequent, and other features we're discussing would make them even less so.
diff --git a/docs/designNotes/2015-05-25 C# Design Meeting.md b/docs/designNotes/2015-05-25 C# Design Meeting.md
deleted file mode 100644
index 2e73fe602614d..0000000000000
--- a/docs/designNotes/2015-05-25 C# Design Meeting.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# C# Design Meeting Notes for May 25, 2015
-
-Discussion for these notes can be found in https://github.com/dotnet/roslyn/issues/3912.
-
-## Agenda
-
-Today we went through a bunch of the proposals on GitHub and triaged them for our list of features in issue #2136. Due to the vastness of the list, we needed to use *some* criterion to sort by, and though far from ideal we ordered them by number of comments, most to least.
-
-Here's where we landed, skipping things that were already "Strong interest". Some are further elaborated in sections below.
-
-1. Method contracts <*Stay at "Some interest"*>(#119)
-2. Destructible types <*Stay at "Probably never"*> (#161)
-3. Params IEnumerable <*Stay at "Small but Useful*>(#36)
-4. Multiple returns <*Addressed by tuples. Close.*> (#102)
-5. More type inference <*Not a coherent proposal. Close*> (#17)
-6. Readonly parameters and locals <*Stay at "Some interest"*>(#115)
-7. Implicitly typed lambdas <*Add at "Probably never"*>(#14)
-8. Immutable types <*Stay at "Some interest*>(#159)
-9. Object initializers for immutable objects <*Add at "Some interest"*>(#229)
-10. First item is special <*Add at "Never"*>(#131)
-11. Array slices <*Keep at "Interesting but needs CLR support"*>(#120)
-12. Vararg calling convention <*Merge with params IEnumerable*>(#37)
-13. XML Literals <*Add to "Never"*>(#1746)
-14. Local Functions <*Move to "Some interest*>(#259)
-15. Covariant returns <*Stay at "Some interest*>(#357)
-
-# Params IEnumerable
-
-This needs more thinking - let's not just implement the straightforward design. There are perf issues, for instance, around implementing through the `IEnumerable` interface instead of arrays directly.
-
-# More type inference
-
-Not a coherent proposal. But even if there was one, we probably wouldn't want it in C#.
-
-# Implicitly typed lambdas
-
-These are mostly subsumed by local functions, which we'd rather do. It has some individual usefulness but not much synergy.
-
-# Object initializers for immutable objects
-
-We want to think this together with withers, not sure what form it would take.
-
-# first item in loops is special
-
-We recognize the scenario but it's not worthy of a feature.
-
-# vararg calling convention
-
-Roll it in with params IEnumerable discussion for investigation.
-
-# XML literals
-
-Never! We won't bake in a specific format.
-
diff --git a/docs/designNotes/2015-07-01 C# Design Meeting.md b/docs/designNotes/2015-07-01 C# Design Meeting.md
deleted file mode 100644
index e685de47ba633..0000000000000
--- a/docs/designNotes/2015-07-01 C# Design Meeting.md
+++ /dev/null
@@ -1,107 +0,0 @@
-# C# Design Meeting Notes for Jul 1, 2015
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/3913.
-
-## Agenda
-
-We are gearing up to prototype the tuple feature, and put some stakes in the ground for its initial design. This doesn't mean that the final design will be this way, and some choices are arbitrary. We merely want to get to where a prototype can be shared with a broader group of C# users, so that we can gather feedback and learn from it.
-
-# Tuples
-
-The tuples proposal #347 is pretty close to what we want, but has some open questions and unaddressed aspects.
-
-## Names
-
-We want the elements of tuples to be able to have names. It is exceedingly useful to be able to describe which elements have which meaning, and to be able to dot into a tuple with those names.
-
-However, it is probably not useful to make the names too strongly a part of the type of a tuple. There is no really good reason to consider (int x, int y) an fundamentally different tuple type than (int a, int b). In fact, according to the analogy with parameter lists, the names should be of secondary importance: useful for getting at the elements, yes, but just as parameter lists with different parameter names can overwrite each other, as long as the types match at the given parameter positions, so should tuple types be considered equivalent when they have the same types at the same positions.
-
-Another way to view it is that all tuples with the same types at the same positions share a common underlying type. We will make that type denotable in the language, in that you can write anonymous tuple types, `(int, int)`, even though you cannot write an anonymous parameter list.
-
-For now we don't think we will allow partially named tuples: it is either all names or none.
-
-``` c#
-(int x, int y) t1 = ...;
-(int a, int b) t2 = t1; // identity conversion
-(int, int) t3 = t1; // identity conversion
-```
-
-All "namings" of a tuple type are considered equivalent, and are convertible to each other via an identity conversion. For type inference purposes, an inferred tuple type will have the names if all "candidate types" with names agree on them, otherwise it will be unnamed.
-
-``` c#
-var a1 = new[]{ t1, t1 }; // infers (int x, int y)[], since all agree
-var a2 = new[]{ t1, t2 }; // infers (int, int)[], since not all agree
-var a3 = new[]{ t1, t3 }; // infers (int x, int y)[] since all with names agree
-```
-
-For method overriding purposes, a tuple type in a parameter or return position can override a differently named tuple type. The rule for which names apply at the call site are the same as those used for named arguments: the names from the most specific statically known overload.
-
-Tuple literals likewise come in named an unnamed versions. They can be target typed, but sometimes have a type of their own:
-
-``` c#
-var t1 = ("Hello", "World"); // infers (string, string)
-var t2 = (first: "John", last: "Doe"); // infers (string first, string last)
-var t3 = ("Hello", null); // fails to infer because null doesn't have a type
-var t4 = (first: "John", last: null); // fails to infer because null doesn't have a type
-
-(string, string) t5 = ("Hello", null); // target typed to (string, string)
-(string first, string last) t6 = ("John", null); // target typed to (string first, string last)
-(string first, string last) t7 = (first: "John", second: "Doe"); // error: when given, names must match up
-(string first, string last) t8 = (last: "Doe", first: "John"); // fine, values assigned according to name
-```
-
-The last two are probably the only possibly controversial examples. When target typing with names in the literal, this seems very similar to using named arguments for a method call. These rules match that most closely.
-
-This is something we may want to return to, as it has some strange consequences. For instance, if we introduce a temporary variable for the tuple, and do not use target typing:
-
-``` c#
-var tmp = (last: "Doe", first: "John"); // infers (string last, string first)
-(string first, string last) t8 = tmp; // assigns by position, so first = "Doe"
-```
-
-But for now, let's try these rules out and see what they feel like.
-
-## Encoding
-
-Are core question is what IL we generate for tuples. The equivalence-across-names semantics make it easy to rely on a fixed set of underlying generic library types.
-
-We want tuples to be value types, since we expect them to be created often and copied less often, so it's probably worthwhile avoiding the GC overhead.
-
-Strangely perhaps, we want tuples to be mutable. We think that there are valid scenarios where you want to keep some data in a tuple, but be able to modify parts of it independently without overwriting the whole tuple. Also, calling methods on readonly tuple members that are themselves value types, would cause those methods to be called on a throw-away copy. This is way too expensive - it means that there may be no non-copying way of doing e.g. value-based equality on such tuples.
-
-So we encode each tuple arity as a generic struct with mutable fields. It would be very similar to the current Tuple<...> types in the BCL, and we would actively avoid purely accidental differences. For this reason, the fields will be called `Item1` etc. Also, tuples bigger than a certain arity (probably 8) will be encoded using nesting through a field called `Rest`.
-
-So we are looking at types like this:
-
-``` c#
-public struct ValueTuple
-{
- public T1 Item1;
- public T2 Item2;
- public T3 Item3;
-}
-```
-
-Possibly with a constructor, some `Equals` and `GetHashCode` overrides and maybe an implementation of `IEquatable<...>` and `IStructurallyEquatable<...>`, but at its core exceedingly simple.
-
-In metadata, a named tuple is represented with its corresponding `ValueTuple<...>` type, plus an attribute describing the names for each position. The attribute needs to be designed to also be able to represent names in nested tuple types.
-
-The encoding means that an earlier version of C#, as well as other languages, will see the tuple members as `Item1` etc. In order to avoid breaking changes, we should probably keep recognizing those names as an alternative way of getting at any tuple's elements. To avoid confusion we should disallow `Item1` etc. as names in named tuples - except, perhaps, if they occur in their right position.
-
-## Deconstruction syntax
-
-Most tuple features have a deconstruction syntax along the following lines:
-
-``` c#
-(int sum, int count) = Tally(...);
-```
-
-If we want such a syntax there are a number of questions to ask, such as can you deconstruct into existing fields or only newly declared ones?
-
-For now we sidestep the question by not adding a deconstruction syntax. The names make access much easier. If it turns out to be painful, we can reconsider.
-
-## Other issues
-
-We will not consider tuples of arity zero or one - at least for now. They may be useful, especially from the perspective of generated source code, but they also come with a lot of questions.
-
-It seems reasonable to consider other conversions, for instance implicit covariant conversions between tuples, but this too we will let lie for now.
diff --git a/docs/designNotes/2015-07-07 C# Design Meeting.md b/docs/designNotes/2015-07-07 C# Design Meeting.md
deleted file mode 100644
index b8a74a47223f7..0000000000000
--- a/docs/designNotes/2015-07-07 C# Design Meeting.md
+++ /dev/null
@@ -1,71 +0,0 @@
-# C# Design Notes for Jul 7 2015
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/5031.
-
-Quotes of the day:
-
-> "I don't think I've had a Quote of the Day for years "
-> "What you just described is awful, so we can't go there!"
-
-## Agenda
-
-With Eric Lippert from Coverity as an honored guest, we looked further at the nullability feature.
-
-1. Adding new warnings
-2. Generics and nullability
-
-# New warnings
-
-The very point of this feature is to give new warnings about existing bugs. What's a reasonable experience here? Ideally folks will always be happy to be told more about the quality of the code. Of course there needs to be super straightforward ways of silencing warnings for people who just need to continue to build, especially when they treat warnings as errors (since those would be breaking). We've previously been burned by providing new warnings that then broke people.
-
-There's a problem when those warnings are false positives, which though hopefully rare, is going to happen: I checked for null in a way the compiler doesn't recognize. Can I build an analyzer to turn warnings *off* if it knows better? Anti-warnings? That's a more general analyzer design question.
-
-Coverity for instance have very advanced analysis to weed out false positives, and avoid the analysis becoming noisy.
-
-# Generics
-
-There's a proposal to treat generics in the following way: Both nullable and nonnullable types are allowed as type arguments. Nullability flows with the type. Type inference propagates nullability - if any input type is nullable the inferred type will be, too.
-
-Constraints can be nullable or nonnullable. Any nonnullable constraints mean that only non-nullable reference types can satisfy them (without warning). Unconstrained generics is reinterpreted to mean constrained by `object?`, in order to continue to allow all safe types as type arguments. If a type parameter `T` is constrained to be nonnullable, `T?` can be used without warning.
-
-Thus:
-
-``` c#
-class C where T : Animal?
-{
- public T x;
- public T? y; // warning
-}
-class D where T : Animal
-{
- public T x;
- public T? y;
-}
-
-C
-C
-
-D
-D // warning
-```
-
-Inside of generics, type parameters are always expected to possibly be nonnullable. Therefore assigning null or nullable values to them always yields a warning (except probably when they are from the *same* possibly nullable type parameter!).
-
-This is nice and consistent. Unfortunately it isn't quite expressive enough. There are cases such as `FirstOrDefault` where we'd really want to return "the nullable version of T if it isn't already nullable". Assume an operator "`^`" (that shouldn't *actually* be the syntax) to mean take the nullable of any nonnullable reference type, leave it alone otherwise:
-
-``` c#
-public static T^ FirstOrDefault(this IEnumerable source);
-
-var a = new string[] { "a", "b", "c" };
-var b = new string[] {};
-
-var couldBeNull = condition ? a.FirstOrDefault() : b.FirstOrDefault(); // string?
-```
-
-We would need to decide what the syntax for `^` *actually* is if we want to have that expressiveness.
-
-`T^` can also serve the purpose of helping null-check code *inside* of a generic method or type. A `List` type for instance could declare its storage array to be `T^[]` instead of `T[]` so that it warns you where you use it that the array elements could be null.
-
-`T?` cannot exist when T is not constrained to either struct or class, because it means different things in the two cases, and we can't code gen across them.
-
-Cast doesn't do null check, just suppresses warning.
diff --git a/docs/designNotes/2015-08-18 C# Design Meeting.md b/docs/designNotes/2015-08-18 C# Design Meeting.md
deleted file mode 100644
index 1abcfcc867776..0000000000000
--- a/docs/designNotes/2015-08-18 C# Design Meeting.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# C# Design Notes for Aug 18, 2015
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/5033.
-
-## Agenda
-
-A summary of the design we (roughly) landed on in #5031 was put out on GitHub as #5032, and this meeting further discussed it.
-
-1. Array creation
-2. Null checking operator
-3. Generics
-
-# Array creation with non-nullable types
-
-For array creation there is the question whether to allow (big hole) or disallow (big nuisance?) on non-nullable referance types. We'll leave it at allow for now, but may reconsider.
-
-# Null checking operator
-
-Casting to a non-nullable reference type would not, and should not, do a runtime null check. Should we, however, have an *operator* for checking null, throwing if the value *is* null, resulting in the non-null value if it isn't?
-
-This seems like a good idea. The operator is postfix `!`, and it should in fact apply to values of nullable *value* types as well as reference types. It "upgrades" the value to non-nullable, by throwing if it is null.
-
-``` c#
-if (person.Kind == Student)
-{
- List courses = person.Courses!; // I know it's not null for a student, but the compiler doesn't.
- ...
-}
-```
-
-The `!` operator naturally leads to `x!.y`, which is great! Although `!.` is two operators, it will feel as a cousin of `?.` (which is one operator). While the latter is conditional on null, the former just plows through. Naively, it implies two redundant null checks, one by `!` and one by `.`, but we'll optimize that of course.
-
-``` c#
-if (person.Kind == Student)
-{
- var passed = !person.Courses!.Any(c => c.Grade == F);
- ...
-}
-```
-
-Technically this would allow `x!?.y`, which comes quite close to swearing. We should consider warning when you use `?.` on non-null things.
-
-VB may have a problem with post-fix `!`. We'll cross that bridge when we get there.
-
-
-# Generics and nullability
-
-Is it too heavyhanded to require `?` on constraints to allow nullable type arguments?
-
-Often, when you have a constraint it is because you want to operate on instances. So it's probably good that the default is not nullable.
-
-It may feel a bit egregious to require it on *all* the constraints of a type parameter, though. Should we put any `?`'s on the type parameter declaration instead of in the constraints? No, that is too weird and different. The case of multiple nullable constraints is probably sufficiently rare that it is reasonable to ask folks to put a `?` on each. In fact we should disallow having `?` on only some, since those question marks won't have an effect: they'll be cancelled by the non-nullable fellow constraints.
-
-The proposal talks about allowing `?` on the use of type parameters to explicitly override their nullness. Maybe we should have an explicit `!` as well, to explicitly override in the other direction: non-nullable. Think for instance of a `FirstNonNull` method.
-
-``` c#
-T! FirstNonNull(IList list) { ... }
-T? FirstOrDefault(IList list) { ... }
-```
-
-This means complexity slowly creeps into the proposal, thanks to generics. However, it seems those overrides are relatively rare, yet really useful when you need them.
-
-`T!` would only be allowed on type parameters, and only when they are not already non-null by constraint.
-
-
diff --git a/docs/designNotes/2015-09-01 C# Design Meeting.md b/docs/designNotes/2015-09-01 C# Design Meeting.md
deleted file mode 100644
index 15ff5192dbc87..0000000000000
--- a/docs/designNotes/2015-09-01 C# Design Meeting.md
+++ /dev/null
@@ -1,156 +0,0 @@
-C# Design Meeting Sep 1 2015
-============================
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/5233.
-
-Agenda
-------
-
-The meeting focused on design decisions for prototypes. There's no commitment for these decisions to stick through to a final feature; on the contrary the prototypes are being made in order to learn new things and improve the design.
-
-1. ref returns and ref locals
-2. pattern matching
-
-
-Ref returns and ref locals
-==========================
-
-Proposal in #118, Initial PR for prototype in #4042.
-
-This feature is a generalization of ref parameters, and as such doesn't have much new, either conceptually or in how you work with it. As is already the case, refs cannot be null (they always reference a memory location), and you access the location they point to without explicitly dereferencing. The new thing is that you can return refs from methods and other functions, and that you can have locals that are refs to other memory locations.
-
-There's a new notion of "safe-to-return". It would be bad if you could return a ref to your own stack frame, for instance. Therefore there's a simple analysis to always track if a ref is "safe-to-return" - and a compile time error if you return something that isn't.
-
-A given method can get refs from a number of places:
-
-1. refs to locals in this method
-2. ref parameters passed to it
-3. refs into heap objects
-4. refs returned from calls
-5. ref locals in this method
-
-The 1st are never safe to return; the 2nd and 3rd always are. The 4th are safe to return if every ref passed *into* the call is safe to return - since we then know that the returned ref cannot be to a local of the calling (or called) method.
-
-The 5th is more involved, as it depends on which semantics we adopt for ref locals.
-
-Ref locals
-----------
-
-There are a couple of different questions to consider for ref locals:
-
-1. Can they be reassigned or are they fixed to a location at declaration time (like ref parameters)?
-2. When are they safe to return? Always? Never? Depends?
-
-If ref locals can be reassignable *and* unsafe-to-return, that means that we have to worry about lifetime analysis:
-
-``` c#
-ref int r;
-while (...)
-{
- int x = ...;
- if (...) ref r = ref x;
-}
-WriteLine(r); // What now?
-```
-
-In other words we have to concern ourselves with the situation where locals are assigned to a ref that is longer lived than the local itself. We would have to detect it and either forbid it or resort to expensive techniques (similar to variable capture by lambdas) that run counter to the perf you were probably hoping for by using refs in the first place.
-
-On the other hand, if ref locals cannot be assigned after initialization, there will be no opportunity to assign variables to them that live in a more nested, and hence shorter-lived, scope. And if they are required to be safe-to-return, then *no* locals can be assigned to them, regardless of lifetime. Either of these seem more attractive!
-
-We think that not being able to assign locals to ref locals is too limiting. For instance, it would be common to keep a struct in a local, and then call a function with a ref to it to locate and return a ref to some data nested in it. You'd want to store the result of that in a ref local:
-
-``` c#
-Node n = ...; struct
-ref Node l = ref GetLeftMostSubNode(ref n);
-l.Contents = ...; // modify leftmost node
-```
-
-So we definitely want to allow ref locals that are non-reassignable and unsafe-to-return.
-
-However, it is also reasonable to want to call similar helper methods on refs that *are* safe to return, to store the results and to then return them:
-
-``` c#
-ref Node M(ref Node n)
-{
- if (...)
- {
- ref Node l = ref GetLeftMostSubNode(ref n);
- l.Contents = ...; // modify leftmost node
- return ref l;
- }
- ...
-}
-```
-
-It seems that we want ref locals to be safe-to-return or not *depending on what they are initialized with*.
-
-We think that there is also some value in having reassignable ref locals. For instance, you can imagine a ref local being the current "pointer" in a loop over a struct array.
-
-We can imagine a rule that simply says that ref locals are reassignable *except if they are initialized with an unsafe-to-return ref*. Then, only safe-to-return refs can be assigned to the reassignable ones, and we still don't have lifetime tracking issues.
-
-On closer scrutiny, though, this scenario does raise harder issues. If you use a ref as a current pointer, what's its initial value? Do we need null refs in the language now? How do you increment it? Can it point "past the edge" at the end?
-
-These are questions we don't want to answer right now for a somewhat hypothetical scenario.
-
-**Conclusion**: for the propotype, ref locals are non-reassignable, and get their "safe-to-return" status from their mandatory ref initializer.
-
-If there are scenarios not covered by this, we'll discover as folks start using the prototype and tell us.
-
-By avoiding reassignment we avoid answering a couple of difficult questions:
-* What's the syntax of a ref assignment? `ref x = y`? `ref x = ref y`? `x = ref y`?
-* Are ref assignments expressions, and what does that mean?
-* Null/default values or definite assignment analysis to prevent the need for them
-
-`this` in structs
------------------
-
-For non-readonly structs, `this` is generally described as being like a ref parameter. However, considering it safe-to-return like ref parameters in struct methods leads to undesirable behavior: It lets a ref to `this` be returned from the method. Therefore a caller needs to consider a ref returned from a method on a struct local *not* safe to return (the returned ref could be the struct local itself or part of it). In essence, the ref `this` "contaminates" any ref-returning method called on a local value type.
-
-Scenarios where this is a problem include using structs as wrapper types for heap objects.
-
-Somewhat counterintuitively perhaps, the better rule is to consider `this` in struct methods unsafe-to-return. Since struct methods will never return a ref to the receiver, you can call them with safe-to-return ref parameters and get safe-to-return ref results.
-
-This also solves a problem with generics, where you don't *know* if a receiver is going to be a struct. Now you don't have to program defensively against that; ref returning methods called on *anything* will be independent of their receiver with regards to safe-to-return determination.
-
-Other issues
-------------
-
-* We may want an unsafe language-level feature to convert between refs and pointers. We'll look at that later.
-* PEVerify considers ref return unsafe. We need to chase that down, but for the prototype it's fine.
-* It'd be useful to have a notion of "readonly refs" - refs through which you cannot write to the referenced storage. This is a separate (big) topic for later.
-
-
-Pattern matching
-================
-
-Proposal in #206, initial PR in #4882.
-
-Syntax: There are patterns, extended is-expressions, and (later) switch.
-``` c#
-pattern:
- *
- type identifier // scope is a separate issue
- type { id is pattern, ... } [identifier]
- type (pattern, ...)
- constant-expression
-
-is-expression:
- relational-expression is pattern
-```
-
-For constants, we would have integral constants be flexible between types. Floats probably not. This has tons of levers, that we can obsess over, but in the prototype this is what we'll go with.
-
-Relational operators in patterns? `e is > 3`? Maybe later.
-
-For VB probably more issues. Save for later.
-
-Scope for variables: in scope in nearest enclosing statement, *except* the else-block of an if-statement. This is a weird but useful exception that allows subsequent else-if's to introduce variables with the same name as previous ones in the conditions.
-
-FOr now, the introduced variables are not reassignable. This could have both positive and negative perf impact. It's an opportunity to do "the right thing", but also a deviation from what we do with other variables. We'll try it in the prototype and see what it feels like.
-
-Deconstruction and guards are interesting further topics that we don't want to pursue yet.
-
-Record types are not part of this prototype.
-
-Some concerns about the active pattern part being too weird or different. Best resolved by prototyping it and playing with it.
-
diff --git a/docs/designNotes/2015-09-02 C# Design Meeting.md b/docs/designNotes/2015-09-02 C# Design Meeting.md
deleted file mode 100644
index 3341bdd72d8a0..0000000000000
--- a/docs/designNotes/2015-09-02 C# Design Meeting.md
+++ /dev/null
@@ -1,102 +0,0 @@
-C# Design Notes Sep 2 2015
-==========================
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/5234.
-
-Quote of the day: Are you pulling the curtain away from my magic retort?
-
-Agenda
-------
-
-1. Extending nameof
-2. What do branches mean
-3. Supersedes
-
-
-Extending nameof
-================
-
-Should we allow empty type argument lists? When we first designed nameof the idea was to allow the same operands as typeof. During design we took it more in the direction of expressions, which seemed more useful.
-
-However, it leaves a nuisance of providing type arguments that don't really provide any value.
-
-One problem with this approach is what to do about situations like `MyList<>.First.P` where `First`'s type is the type parameter of `MyList`.
-
-We would think of `MyList<>` as having a type argument that has no members at all - not even the ones from object. Thus, if you dot on it, you get an error.
-
-More simply, just allow what's in typeof, followed by one member access. Make sure that, like in typeof, type arguments are either given everywhere or nowhere.
-
-For inherited members/nested types, we should do the same as typeof does.
-
-We don't expect this to upset analyzers much. We would make sure that the unbound types do have members in the semantic model. *Those* members just don't have members. Thus `MyList<>.First` is fine, but `MyList<>.First.P` is not.
-
-We like this.
-
-What do branches mean
-=====================
-
-As prototypes start to come online, we need to decide how we use our pbranches. The Future branch is for when things are at prototype level for the whole experience - including IDE. Features will be guarded by a feature flag until it's the confident plan of record to ship the feature in its current form.
-
-We are working on enabling VSIXes to change the language model in the IDE without the need for customers to install over VS. Hopefully this capability will be available in an update to VS in a not too distant future. Once that is in place, we can ship prototypes that run without risk to customers' VS installation.
-
-
-Supersedes
-==========
-
-For metaprogramming, like Javas annotation processing tool (APT), we would like to facilitate generating additional code from existing code (e.g. based on attributes or patterns). Roslyn now provides an excellent stack for that.
-
-As a language C# is already better suited for this than Java because of partial types and methods: they allow the merging of existing and generated code to be less convoluted.
-
-However we can do even better. We can allow omitting `partial` on one of the parts, so the user written code doesn't need it. But more interestingly we can consider a `supersedes` feature (where the keyword `supersedes` may need to be replaced by something that people have less trouble spelling!):
-
-``` c#
-class C
-{
- public void M()
- {
- // do stuff
- }
-
- [INPC] public int X {
- get { ... }
- set { ... }
-}
-
-// generated
-partial class C
-{
- public supersedes void M()
- {
- // do something
- superseded(); // calls original method
- // do more
- }
-
- public supersedes int X {
- get { return superseded; }
- set
- {
- superseded = value;
- RaiseNPC(nameof(X));
- }
- }
-}
-```
-
-The compiler would generate code to keep the original `M` and `X` under a mangled name, inlined or something.
-
-Challenge: composing multiple rewriters: either we have an ordering rule, or we get errors. This is a challenging problem.
-
-Another good question: Do you have just one generator phase, or keep going to a fix point. Java keeps going until no changes.
-
-Is the generated code visible to the user? You should see it like generated code today, and the compiler would parse it again to guard from mistakes. That way, code could also be generated by t4 and other tools, as well as Roslyn.
-
-Concern: we are adding a new concept. Would it be better to use existing concepts, like Java does?
-
-Concern: efficiency. Forces binding, throws away first result and binds again against generated code.
-
-This is very interesting and promising, but there are many juicy challenges ahead.
-
-
-
-
\ No newline at end of file
diff --git a/docs/designNotes/2015-09-08 C# Design Meeting.md b/docs/designNotes/2015-09-08 C# Design Meeting.md
deleted file mode 100644
index 408c4dd2f6b19..0000000000000
--- a/docs/designNotes/2015-09-08 C# Design Meeting.md
+++ /dev/null
@@ -1,173 +0,0 @@
-# C# Design Notes for Sep 8, 2015
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/5383.
-
-## Agenda
-
-1. Check-in on some of our desirable features to see if we have further thoughts
-2. Start brainstorming on async streams
-
-
-# Check-in on features
-
-## Bestest betterness
-
-Overload resolution will sometimes pick a candidate method only to lead to an error later on. For instance, it may pick an instance method where only a static one is allowed, a generic method where the constraints aren't satisfied or an overload the relies on a method group conversion that will ultimately fail.
-
-The reason for this behavior is usually to keep the rules simple, and to avoid accidentally picking another overload than what you meant. However, it also leads to quite a bit of frustration. It might be time to sharpen the rules.
-
-## Private protected
-
-In C# 6 we considered adding a new accessibility level with the meaning protected *and* internal (`protected internal` means protected *or* internal), but gave up because it's hard to settle on a syntax. We wanted to use `private protected` but got a lot of loud push back on it.
-
-No-one has come up with a better syntax in the meantime though. We are inclined to think that `private protected` just takes a little getting used to. We may want to try again.
-
-## Attributes
-
-There are a number of different features related to attributes. We should return to these in a dedicated meeting looking at the whole set of proposals together:
-
-* Generic attributes: They seem to be allowed by the runtime, but for some reason are disallowed by the language
-* Compile-time only attributes: For attributes that are intended to be used only before IL gen, it'd be nice to have them elided and not bloat metadata
-* Attributes in more places: There are more places where it makes sense to allow attributes, such as on lambda expressions. If they are compile-time only, they can even be in places where there is no natural code gen.
-* Attributes of more types: For attributes that are not going into code gen, we could relax the restrictions on the types of their constructor parameters.
-
-A lot of these would be particularly helpful to Roslyn based tools such as analyzers and metaprogramming.
-
-## Local extern functions
-
-We should allow local functions to be extern. You'd almost always want to wrap an extern method in a safe to call wrapper method.
-
-## Withers for arbitrary types
-
-If we want to start focusing more on immutable data structures, it would be nice if there was a language supported way of creating new objects from existing ones, changing some subset of properties along the way:
-
-``` c#
-var newIfStatement = ifStatement with { Condition = newCondition, Statement = newStatement }; // other properties copied
-```
-
-Currently the Roslyn code base, for example, uses the pattern of "withers", which are methods that return a new object with one property changed. There needs to be a wither per property, which is quite bloatful, and in Roslyn made feasible by having them automatically generated. Even so, changing multiple properties is suboptimal:
-
-``` c#
-var newIfStatement = ifStatement.WithCondition(newCondition).WithStatement(newStatement);
-```
-
-It would be nice if we could come up with an efficient API pattern to support a built-in, efficient `with` expression.
-
-Related to this, it would also be nice to support object initializers on immutable objects. Again, we would need to come up with an API pattern to support it; possibly the same that would support the with expression.
-
-## Params IEnumerable
-
-This is a neat little feature that we ultimately rejected or didn't get to in C# 6. It lets you do away with the situation where you have to write two overloads of a method, one that takes an `IEnumerable` (for generality) and another one that takes `params T[]` and calls the first one with its array.
-
-The main problem raised against params IEnumerable is that it encourages an inefficient pattern for how parameters are captured: An array is allocated even when there are very few arguments (even zero!), and the implementation then accesses the elements through interface dispatches and further allocation (of an IEnumerator).
-
-Probably this won't matter for most people - they can start out this way, and then build a more optimal pattern if they need to. But it might be worthwhile considering a more general language pattern were folks can build a params implementation targeting something other than arrays.
-
-
-# Async streams
-
-We shied back from a notion of asynchronous sequences when we originally introduced async to C#. Part of that was to see whether there was sufficient demand to introduce framework and language level concepts, and get more experience to base their design on. But also, we had some fear that using async on a per-element level would hide the true "chunky" degree of asynchrony under layers of fine-grained asynchronous abstractions, at great cost to performance.
-
-## IAsyncEnumerable
-
-At this point in time, though, we think that there is definitely demand for common abstractions and language support: foreach'ing, iterators, etc. Furthermore we think that the performance risks - allocation overhead in particular - of fine grained asynchrony can large be met with a combination of the compiler's existing optimizations and a straightforward asynchronous "translation" of `IEnumerable` into `IAsyncEnumerable`:
-
-``` c#
-public interface IAsyncEnumerable
-{
- public IAsyncEnumerator GetEnumerator();
-}
-
-public interface IAsyncEnumerator
-{
- public T Current { get; }
- public Task MoveNextAsync();
-}
-```
-
-The only meaningful difference is that the `MoveNext` method of the enumerator interface has been made async: it returns `Task` rather than `bool`, so that you need to await it to find out whether there is a next element (which you can then acquire from the `Current` property) or the sequence is finished.
-
-## Allocations
-
-Let's assume that you are foreach'ing over such an asynchronous sequence, which is buffered behind the scenes, so that 99.9% of the time an element is available locally and synchronously. Whenever a `Task` is awaited that is already completed, the compiler avoids the heavy machinery and just gets the value straight out of the task without pause. If *all* awaited Tasks in a given method call are already completed, then the method will never allocate a state machine, or a delegate to store as a continuation, since those are only constructed the first time they are needed.
-
-Even when the async method reaches its return statement synchronously, without the awaits having ever paused, it needs to construct a Task to return. So normally this would still require one allocation. However, the helper API that the compiler uses for this will actually cache completed Tasks for certain common values, including `true` and `false`. In summary, a `MoveNextAsync` call on a sequence that is buffered would typically not allocate anything, and the calling method often wouldn't either.
-
-The lesson is that fine-grained asynchrony is bad for performance if it is done in terms of `Task` where completed Tasks are never or rarely cached, e.g. `Task` or `Task`. It should be done in terms of `Task` or even non-generic `Task`.
-
-We think that there may or may not be scenarios where people want to get explicit about the "chunks" that data is transmitted in. If so, they can express this as `IAsyncEnumerable>` or some such thing. But there is no need to complicate asynchronous streaming by forcing people to deal with chunking by default.
-
-## Linq bloat
-
-Another concern is that there are many API's on `IEnumerable` today; not least the Linq query operators `Select`, `Where` and so on. Should all those be duplicated for `IAsyncEnumerable`?
-
-And when you think about it, we are not just talking about one extra set of overloads. Because once you have asynchronously foreach'able streams, you'll quickly want the delegates applied by the query operators to *also* be allowed to be async. So we have potentially four combinations:
-
-``` c#
-public static IEnumerable Where(this IEnumerable source, Func predicate);
-public static IAsyncEnumerable Where(this IAsyncEnumerable source, Func predicate);
-public static IAsyncEnumerable Where(this IEnumerable source, Func> predicate);
-public static IAsyncEnumerable Where(this IAsyncEnumerable source, Func> predicate);
-```
-
-So either we'd need to multiply the surface area of Linq by four, or we'd have to introduce some new implicit conversions to the language, e.g. from `IEnumerable` to `IAsyncEnumerable` and from `Func` to `Func>`. Something to think about, but we think it is probably worth it to get Linq over asynchronous sequences one way or another.
-
-Along with this, we'd need to consider whether to extend the query syntax in the language to also produce async lambdas when necessary. It may not be worth it - using the query operators may be good enough when you want to pass async lambdas.
-
-## Language support
-
-In the language we would add support for foreach'ing over async sequences to consume them, and for async iterators to produce them. Additionally (we don't discuss that further here) we may want to introduce a notion of `IAsyncDisposable`, for weach we could add an async version of the `using` statement.
-
-One concern about async versions of language features such as foreach (and using) is that they would generate `await` expressions that aren't there in source. Philosophically that may or may not be a problem: do you want to be able to see where all the awaiting happens in your async method? If that's important, we can maybe add the `await` or `async` keyword to these features somewhere:
-
-``` c#
-foreach (string s in asyncStream) { ... } // or
-foreach async (string s in asyncStream) { ... } // or
-foreach (await string s in asyncStream) { ... } // etc.
-```
-
-Equally problematic is when doing things such as `ConfigureAwait`, which is important for performance reasons in libraries. If you don't have your hands on the Task, how can you `ConfigureAwait` it? The best answer is to add a `ConfigureAwait` extension method to `IAsyncEnumerable` as well. It returns a wrapper sequence that will return a wrapper enumerator whose `MoveNextAsync` will return the result of calling `ConfigureAwait` on the task that the wrapped enumerator's `MoveNextAsync` method returns:
-
-``` c#
-foreach (string s in asyncStream.ConfigureAwait(false)) { ... }
-```
-
-For this to work, it is important that async foreach is pattern based, just like the synchronous foreach is today, where it will happily call any `GetEnumerator`, `MoveNext` and `Current` members, regardless of whether objects implement the official "interfaces". The reason for this is that the result of `Task.ConfigureAwait` is not a `Task`.
-
-A related issue is cancellation, and whether there should be a way to flow a `CancellationToken` to the `MoveNextAsync` method. It probably has a similar solution to `ConfigureAwait`.
-
-## Channels in Go
-
-The Go language has a notion of channels, which are communication pipes between threads. They can be buffered, and you can put things in and take them out. If you put things in while the channel is full, you wait. If you take things out while it is empty, you wait.
-
-If you imagine a `Channel` abstraction in .NET, it would not have blocking waits on the endpoints; those would instead be asynchronous methods returning Tasks.
-
-Go has an all-powerful language construct called `select` to consume the first available element from any set of channels, and choosing the logic to apply to that element based on which channel it came from. It is guaranteed to consume a value from only one of the channels.
-
-It is worthwhile for us to look at Go channels, learn from them and consider to what extent a) we need a similar abstraction and b) it is connected to the notion of async streams.
-
-Some preliminary thoughts: Channels and select statements are very easy to understand, conceptually. On the other hand they are somewhat low-level, and extremely imperative: there is a strong coupling from the consumer to the producer, and in practice there would typically only *be* one consumer. It seems like a synchronization construct like semaphores or some of the types from the DataFlow library.
-
-The "select" functionality is interesting to ponder more generally. If you think about it from an async streams perspective, maybe the similar thing you would do would be to merge streams. That would need to be coupled with the ability to tie different functionality to elements from different original streams - or with different types. Maybe pattern matching is our friend here?
-
-``` c#
-foreach (var e in myInts.Merge(myStrings))
-{
- switch (e)
- {
- case int i:
- ...
- case string s:
- ...
- }
-}
-```
-
-Either way, it isn't as elegant by a long shot. If we find it's important, we'd need to consider language support.
-
-Another important difference between IAsyncEnumerable and Channels is that an enumerable can have more than one consumer. Each enumerator is independent of the others, and provides access to all the members - at least from the point in time where it is requested.
-
-
-## Conclusion
-
-We want to keep thinking about async streams, and probably do some prototyping.
\ No newline at end of file
diff --git a/docs/designNotes/2015-10-07 C# Design Review Notes.md b/docs/designNotes/2015-10-07 C# Design Review Notes.md
deleted file mode 100644
index 02447f947d0ee..0000000000000
--- a/docs/designNotes/2015-10-07 C# Design Review Notes.md
+++ /dev/null
@@ -1,135 +0,0 @@
-Notes on Records and Pattern Matching for 2015-10-07 design review
-==================================================================
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/5757.
-
-### Records and Pattern Matching (https://github.com/dotnet/roslyn/issues/206)
-
-Prototyped together last year by @semihokur, but that prototype is
-based on very out-of-date Roslyn code. We also have some design changes
-since that time and we want to separate a pattern-matching prototype from
-records/ADTs so we can make independent decisions about whether
-and when to include them in the language(s).
-
-First step is to port pattern matching to the latest sources.
-In-progress port at https://github.com/dotnet/roslyn/pull/4882
-
-### Spec changes since the 2014 prototype
-
-For pattern matching:
-
-1. Scoping of pattern-introduced variables (with "funny" rule for `if`)
-2. Rules for `switch` statement that make it a compatible extension of the existing construct (https://github.com/dotnet/roslyn/issues/4944)
-3. An expression form of multi-arm pattern-matching (https://github.com/dotnet/roslyn/issues/5154)
-4. A `when` clause added to `switch` cases.
-
-And, for records:
-
-1. No `record` keyword necessary
-2. `with` expressions (https://github.com/dotnet/roslyn/issues/5172)
-3. Approach for for algebraic data types
-
-### Implementation status of prototype port
-
-1. For pattern matching, checklist at https://github.com/dotnet/roslyn/pull/4882 tracking the progress
-2. For records, port not started
-
-### Making the extension of `switch` backward-compatible
-
-- We say that the cases are matched in order, except `default` which is always the last
-resort.
-
-- Integral-typed case labels match any integral-valued control expression with the same value.
-
-- One issue around user-defined conversions to switchable types is
-resolved (https://github.com/dotnet/roslyn/issues/4944). In the draft spec,
-a conversion will be applied on the `case`s, not on the control-expression unilaterally.
-Instead of converting only to `swithable` types, each
-`case` arm will consider any conversions that allow the `case` to be applied.
-Any given conversion would be applied at most once.
-
-```cs
-Foo foo = ...; // has a conversion to int
-switch (foo)
-{
- case 1: // uses the converted value
- case Foo(2): // uses the original value
- case 3: // uses the converted value
-}
-```
-
-- The `goto case` statement is extended to allow any expression as its argument.
-
-### Expression form of multi-arm pattern matching (https://github.com/dotnet/roslyn/issues/5154)
-
-```cs
-var areas =
- from primitive in primitives
- let area = primitive match (
- case Line l: 0
- case Rectangle r: r.Width * r.Height
- case Circle c: Math.PI * c.Radius * c.Radius
- case *: throw new ApplicationException()
- )
- select new { Primitive = primitive, Area = area };
-```
-
-There is no `default` here, so cases are handled strictly in order.
-
-I propose the spec require that the compiler "prove" that all cases are handled
-in a `match` expression using not-yet-specified rules. Writing those rules
-is an open work item, but I imagine it will require the compiler to build
-a decision tree and check it for completeness. That will also be needed to
-implement checks that no case is subsumed by a previous case, which will
-cause a warning (for `switch`) or error (for `match`).
-
-### With-expressions (https://github.com/dotnet/roslyn/issues/5172)
-
-```cs
-class Point(int X, int Y, int Z);
-...
- Point p = ...;
- Point q = p with { Y = 2 };
-```
-
-The latter is translated into
-
-```cs
- Point q = new Point(X: p.X, Y: 2, Z: p.Z);
-```
-
-We know how to do this for record types (because the language specifies the
-mapping between constructor parameters and properties). We're examining how
-to extend it to more general types.
-
-To support inheritance, rather than directly using the constructor (as above) the generated code will
-invoke a compiler-generated (but user-overridable) factory method.
-
-```cs
- Point q = p.With(X: p.X, Y: 2, Z: p.Z);
-```
-
-### Draft approach for algebraic data types
-
-```cs
-abstract sealed class Expression
-{
- class Binary(Operator Operator, Expression Left, Expression Right) : Expression;
- class Constant(int Value) : Expression;
-}
-```
-
-None of these classes would be permitted to be extended elsewhere.
-a `match` expression that handles both `Binary` and `Constant` cases
-would not need a `*` (default) case, as the compiler can prove it
-is complete.
-
-### Remaining major issues
-
-1. We need to specify the rules for checking
- - If the set of cases in a `match` is complete
- - If a `case` is subsumed by a previous `case`
-
-2. We need more experience with algebraic data types and active patterns.
-
-3. Can we extend `with` expressions to non-record types?
diff --git a/docs/designNotes/2015-11-02 C# Design Demo.md b/docs/designNotes/2015-11-02 C# Design Demo.md
deleted file mode 100644
index 392e19ce6bde3..0000000000000
--- a/docs/designNotes/2015-11-02 C# Design Demo.md
+++ /dev/null
@@ -1,251 +0,0 @@
-Here’s an outline of a demo at the MVP summit on 2015-11-02
-===========================================================
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/6505.
-
-### Let’s talk about local functions.
-
-A method often has other private “helper” methods that are used in its implementation. Those methods are in the scope of the enclosing type, even though they are only intended to be used in a single place. Local functions allow you to define a function where it is used. For example, given a helper method
-
- static int Fib(int n)
- {
- return (n < 2) ? 1 : Fib(n - 1) + Fib(n - 2);
- }
-
-Or, using the new syntax added in C# 6:
-
- static int Fib(int n) => (n < 2) ? 1 : Fib(n - 1) + Fib(n - 2);
-
-And the method that it is used in
-
- static void Main(string[] args)
- {
- Console.WriteLine(Fib(7));
- Console.ReadKey();
- }
-
-In C# 7 you’ll be able to define the helper function in the scope where it is used:
-
- static void Main(string[] args)
- {
- int Fib(int n) => (n < 2) ? 1 : Fib(n - 1) + Fib(n - 2); //!
-
- Console.WriteLine(Fib(7));
- Console.ReadKey();
- }
-
-Local functions can use variables from the enclosing scope:
-
- static void Main(string[] args)
- {
- int fib0 = 1; //!
- int Fib(int n) => (n < 2) ? fib0 : Fib(n - 1) + Fib(n - 2);
-
- Console.WriteLine(Fib(7));
- Console.ReadKey();
- }
-
-You can imagine having to pass such state as additional parameters to a helper method if it were declared in the enclosing type, but local function can use local variables directly.
-
-Capturing state like this does not require allocating frame objects on the heap as it would for delegates, or allocating a delegate object either, so this is much more efficient than what you would have to do to simulate this feature by hand.
-
-### Let’s talk about pattern matching.
-
-With object-oriented programming, you define a virtual method when you have to dispatch an operation on the particular kind of object. That works best when the author of the types can identify ahead of time all of the operations (virtual methods) on the types, but it enables you to have an open-ended set of types.
-
-In the functional style, on the other hand, you define your data as a set of types without virtual functions, and define the functions separately from the data. Each operation provides an implementation for each type in the type hierarchy. That works best when the author of the types can identify ahead of time all of the shapes of the data, but it enables you to have an open-ended set of operations.
-
-C# does a great job for the object-oriented style, but the functional style (where you cannot identify all the operations ahead of time) shows up as a frequent source of awkwardness in C# programs.
-
-Let’s get really concrete. Suppose I have a small hierarchy of types
-
- // class Person(string Name);
- class Person
- {
- public Person(string name) { this.Name = name; }
- public string Name { get; }
- }
-
- // class Student(string Name, double Gpa) : Person(Name);
- class Student : Person
- {
- public Student(string name, double gpa) : base(name)
- { this.Gpa = gpa; }
- public double Gpa { get; }
- }
-
- // class Teacher(string Name, string Subject) : Person(Name);
- class Teacher : Person
- {
- public Teacher(string name, string subject) : base(name)
- { this.Subject = subject; }
- public string Subject { get; }
- }
-
-The comments, by the way, shows a possible future syntax we are considering for C# 7 that we call records. We’re still working on records, so I won’t say more about that today. Here is an operation that uses these types
-
- static string PrintedForm(Person p)
- {
- Student s;
- Teacher t;
- if ((s = p as Student) != null && s.Gpa > 3.5)
- {
- return $"Honor Student {s.Name} ({s.Gpa})";
- }
- else if (s != null)
- {
- return $"Student {s.Name} ({s.Gpa})";
- }
- else if ((t = p as Teacher) != null)
- {
- return $"Teacher {t.Name} of {t.Subject}";
- }
- else
- {
- return $"Person {p.Name}";
- }
- }
-
-And for the purposes of the demo, a client of that operation
-
- static void Main(string[] args)
- {
- Person[] oa = {
- new Student("Einstein", 4.0),
- new Student("Elvis", 3.0),
- new Student("Poindexter", 3.2),
- new Teacher("Feynmann", "Physics"),
- new Person("Anders"),
- };
- foreach (var o in oa)
- {
- Console.WriteLine(PrintedForm(o));
- }
- Console.ReadKey();
- }
-
-Note the need to declare the variables `s` and `t` ahead of time in `PrintedForm`. Even though they are only used in one branch of the series of if-then-else statements, they are in scope throughout. That means that you have to think up distinct names for all of these temporary variables. As part of the pattern-matching feature we are repurposing the “is” operator to take a pattern on the right-hand-side. And one kind of pattern is a variable declaration. That allows us to simplify the code like this
-
- static string PrintedForm(Person p)
- {
- if (p is Student s && s.Gpa > 3.5) //!
- {
- return $"Honor Student {s.Name} ({s.Gpa})";
- }
- else if (p is Student s)
- {
- return $"Student {s.Name} ({s.Gpa})";
- }
- else if (p is Teacher t)
- {
- return $"Teacher {t.Name} of {t.Subject}";
- }
- else
- {
- return $"Person {p.Name}";
- }
- }
-
-
-Now the temporary variables `s` and `t` are declared and scoped to just the place they need to be. Unfortunately we’re testing against the type `Student` more than once. Back to that in a moment.
-
-We’ve also repurposed the `switch` statement so that the case branches are patterns instead of just constants (though constants are one kind of pattern). That enables you to use `switch` as a "type switch":
-
- static string PrintedForm(Person p)
- {
- switch (p) //!
- {
- case Student s when s.Gpa > 3.5 :
- return $"Honor Student {s.Name} ({s.Gpa})";
- case Student s :
- return $"Student {s.Name} ({s.Gpa})";
- case Teacher t :
- return $"Teacher {t.Name} of {t.Subject}";
- default :
- return $"Person {p.Name}";
- }
- }
-
-The compiler is careful so that we don’t type-test against `Student` more than once in the generated code for `switch`.
-
-Note the new `when` clause in the switch statement.
-
-We’re also working on an expression equivalent to the switch statement, which is like a multi-branch `?:` operator for pattern matching:
-
- static string PrintedForm(Person p)
- {
- return p match ( //!
- case Student s when s.Gpa > 3.5 :
- $"Honor Student {s.Name} ({s.Gpa})"
- case Student s :
- $"Student {s.Name} ({s.Gpa})"
- case Teacher t :
- $"Teacher {t.Name} of {t.Subject}"
- case * :
- $"Person {p.Name}"
- );
- }
-
-Because you sometimes need to throw an exception when some condition is unexpected, we’re adding a *throw expression* that you can use in a match expression:
-
- return p match (
- case Student s when s.Gpa > 3.5 :
- $"Honor Student {s.Name} ({s.Gpa})"
- case Student s :
- $"Student {s.Name} ({s.Gpa})"
- case Teacher t :
- $"Teacher {t.Name} of {t.Subject}"
- case null :
- throw new ArgumentNullException(nameof(p)) //!
- case * :
- $"Person {p.Name}"
- );
-
-Another useful kind of pattern allows you to match on members of a type:
-
- return p match (
- case Student s when s.Gpa > 3.5 :
- $"Honor Student {s.Name} ({s.Gpa})"
- case Student { Name is "Poindexter" } : //!
- "A Nerd"
- case Student s :
- $"Student {s.Name} ({s.Gpa})"
- case Teacher t :
- $"Teacher {t.Name} of {t.Subject}"
- case null :
- throw new ArgumentNullException(nameof(p))
- case * :
- $"Person {p.Name}"
- );
-
-Since this is an expression, we can use the new “=>” form of a method. Our final method is
-
- static string PrintedForm(Person p) => p match (
- case Student s when s.Gpa > 3.5 :
- $"Honor Student {s.Name} ({s.Gpa})"
- case Student { Name is "Poindexter" } :
- "A Nerd"
- case Student s :
- $"Student {s.Name} ({s.Gpa})"
- case Teacher t :
- $"Teacher {t.Name} of {t.Subject}"
- case null :
- throw new ArgumentNullException(nameof(p))
- case * :
- $"Person {p.Name}"
- );
-
-In summary:
-- Local functions (capturing state is cheap)
-- Pattern-matching
- - Operator is
- - Switch, “when” clauses
- - `match` expression
- - Patterns
- - Constant patterns e.g. `1` in an ordinary switch
- - type-match patterns e.g. `Student s`
- - property patterns e.g. `Student { Name is "Poindexter" }`
- - wildcard e.g. `*`
-- Still working on
- - Records, algebraic data types
- - Tuples
diff --git a/docs/designNotes/2016-02-29 C# Design Meeting.md b/docs/designNotes/2016-02-29 C# Design Meeting.md
deleted file mode 100644
index d7bc7aa198ac1..0000000000000
--- a/docs/designNotes/2016-02-29 C# Design Meeting.md
+++ /dev/null
@@ -1,188 +0,0 @@
-C# Language Design Notes Feb 29, 2016
-=====================================
-
-Discussion for these notes can be found at https://github.com/dotnet/roslyn/issues/9330.
-
-## Catch up edition (deconstruction and immutable object creation)
-
-Over the past couple of months various design activities took place that weren't documented in design notes. The following is a summary of the state of design regarding positional deconstruction, with-expressions and object initializers for immutable types.
-
-# Philosophy
-
-We agree on the following design tenets:
-
-Positional deconstruction, with-expressions and object initializers are separable features, enabled by the presence of certain API patterns on types that can be expressed manually, as well as generated by other language features such as records.
-
-# API Patterns
-
-API patterns for a language feature facilitate two things:
-
-* Provide actual APIs to call _at runtime_ when the language feature is used
-* Inform the compiler _at compile time_ about how to generate code for the feature
-
-It turns out the biggest design challenges are around the second part. Specifically, all these API patterns turn out to need to bridge between positional and name-based expressions of the members of types. How each API pattern does that is a central question of its design.
-
-Assume the following running example:
-
-``` c#
-public class Person
-{
- public string FirstName { get; }
- public string LastName { get; }
-
- public Person(string firstName, string lastName)
- {
- FirstName = firstName;
- LastName = lastName;
- }
-}
-```
-
-In the following we'll consider extending and changing this type to expose various API patterns as we examine the individual language features.
-
-Here's an example of using the three language features:
-
-``` c#
-var p = new Person { FirstName = "Mickey", LastName = "Mouse" }; // object initializer
-if (p is Person("Mickey", *)) // positional deconstruction
-{
- return p with { FirstName = "Minney" }; // with-expression
-}
-```
-
-Semantically this corresponds to something like this:
-
-``` c#
-var p = new Person("Mickey", "Mouse"); // constructor call
-if (p.FirstName == "Mickey") // property access
-{
- return new Person("Minney", p.LastName); // constructor call
-}
-```
-
-Notice how the new features that use property names correspond to API calls using positional parameters, whereas the feature that uses positions corresponds to member access by name!
-
-# Object initializers for immutable objects
-(See e.g. #229)
-
-This feature allows an object initializer for which assignable properties are not found, to fall back to a constructor call taking the properties' new values as arguments.
-
-``` c#
-new Person { FirstName = "Mickey", LastName = "Mouse" }
-```
-becomes
-``` c#
-new Person("Mickey", "Mouse")
-```
-
-The question then is: how does the compiler decide to pass the given FirstName as the first argument? Somehow it needs clues from the `Person` type as to which properties correspond to which constructor parameters. These clues cannot just be the constructor body: we need this to work across assemblies, so the clues must be evident from metadata.
-
-Here are some options:
-
-1: The type or constructor explicitly includes metadata for this purpose, e.g. in the form of attributes.
-2: The names of the constructor parameters must match exactly the names of the corresponding properties.
-
-The former is unattractive because it requires the type's author to write those attributes. It requires the type to be explicitly edited for the purpose.
-
-The latter is better in that it doesn't require extra API elements. However, API design guidelines stipulate that public properties start with uppercase, and parameters start with lower case. This pattern would break that, and for the same reason is highly unlikely to apply to any existing types.
-
-This leads us to:
-
-3: The names of the constructor parameters must match the names of the corresponding properties, _modulo case_!
-
-This would allow a large number of existing types to just work (including the example above), but at the cost of introducing case insensitivity to this part of the C# language.
-
-# With-expressions
-(see e.g. #5172)
-
-With-expressions are similar to object initializers, except that they provide a source object from which to copy all the properties that aren't specified. Thus it seems reasonable to use a similar strategy for compilation; to call a constructor, this time filling in missing properties by accessing those on the source object.
-
-Thus the same strategies as above would apply to establish the connection between properties and constructor parameters.
-
-``` c#
-p with { FirstName = "Minney" }
-```
-becomes
-``` c#
-new Person("Minney", p.LastName)
-```
-
-However, there's a hitch: if the runtime source object is actually of a derived type with more properties than are known from its static type, it would typically be expected that those are copied over too. In that case, the static type is also likely to be abstract (most base types are), so it wouldn't offer a callable constructor.
-
-For this situation there needs to be a way that an abstract base class can offer "with-ability" that correctly copies over members of derived types. The best way we can think of is to offer a virtual `With` method, as follows:
-
-``` c#
-public abstract class Person
-{
- ...
- public abstract Person With(string firstName, string lastName);
-}
-```
-
-In the presence of such a `With` method we would generate a with expression to call that instead of the constructor:
-
-``` c#
-p.With("Minney", p.LastName)
-```
-
-We can decide whether to make with-expressions _require_ a `With` method, or fall back to constructor calls in its absence.
-
-If we _require_ a `With` method, that makes for less interoperability with existing types. However, it gives us new opportunities for how to provide the position/name mapping metadata thorugh the declaration of that `With` method: For instance, we could introduce a new kind of default parameter that explicitly wires the parameter to a property:
-
-``` c#
- public abstract Person With(string firstName = this.FirstName, string lastName = this.LastName);
-```
-
-To explicitly facilitate interop with an existing type, a mandatory `With` method could be allowed to be provided as an extension method. It is unclear how that would work with the default parameter approach, though.
-
-# Positional deconstruction
-(see e.g. #206)
-
-This feature allows a positional syntax for extracting the property values from an object, for instance in the context of pattern matching, but potentially also elsewhere.
-
-Ideally, a positional deconstruction would simply generate an access of each member whose value is obtained:
-
-``` c#
-p is Person("Mickey", *)
-```
-becomes
-``` c#
-p.FirstName == "Mickey"
-```
-
-Again, this requires the compiler's understanding of how positions correspond to property names. Again, the same strategies as for object initializers are possible. See e.g. #8415.
-
-Additionally, just as in with-expressions, one might wish to override the default behavior, or provide it if names don't match. Again, an explicit method could be used:
-
-``` c#
-public abstract class Person
-{
- ...
- public void Person GetValues(out string firstName, out string lastName);
-}
-```
-There are several options as to the shape of such a method. Instead of out-parameters, it might return a tuple. This has pros and cons: there could be only one tuple-returning `GetValues` method, because there would be no parameters to distinguish signatures. This may be a good or a bad thing.
-
-Just as the `With` method, we can decide whether deconstruction should _require_ a `GetValues` method, or should fall back to metadata or to name matching against the constructor's parameter names.
-
-If the `GetValues` method is used, the compiler doesn't need to resolve between positions and properties: the deconstruction as well as the method are already positional. We'd generate the code as follows:
-
-``` c#
-string __p1;
-string __p2;
-p.GetValues(out __p1, out __p2);
-...
-__p1 == "Mickey"
-```
-
-Somewhat less elegant for sure, and possibly less efficient, since the `LastName` is obtained for no reason. However, this is compiler generated code that no one has to look at, and it can probably be optimized, so this may not be a big issue.
-
-# Summary
-
-For each of these three features we are grappling with the position-to-property match. Our options:
-
-1. Require specific metadata
-2. Match property and parameter names, possibly in a case sensitive way
-3. For deconstruction and with-expressions, allow or require specific methods (`GetValues` and `With` respectively) to implement their behavior, and possibly have special syntax in `With` methods to provide the name-to-position matching.
-
-We continue to work on this.
\ No newline at end of file
diff --git a/docs/designNotes/2016-04-06 C# Design Meeting.md b/docs/designNotes/2016-04-06 C# Design Meeting.md
deleted file mode 100644
index 73c9de2e64c8a..0000000000000
--- a/docs/designNotes/2016-04-06 C# Design Meeting.md
+++ /dev/null
@@ -1,267 +0,0 @@
-C# Design Notes for Apr 6, 2016
-===============================
-
-Discussion for these design notes can be found at https://github.com/dotnet/roslyn/issues/10429.
-
-We settled several open design questions concerning tuples and pattern matching.
-
-# Tuples
-
-## Identity conversion
-
-Element names are immaterial to tuple conversions. Tuples with the same types in the same order are identity convertible to each other, regardless of the names.
-
-That said, if you have an element name at *one* position on one side of a conversion, and the same name at *another* position on the other side, you almost certainly have bug in your code:
-
-``` c#
-(string first, string last) GetNames() { ... }
-(string last, string first) names = GetNames(); // Oops!
-```
-
-To catch this glaring case, we'll have a warning. In the unlikely case that you meant to do this, you can easily silence it e.g. by assigning through a tuple without names at all.
-
-## Boxing conversion
-
-As structs, tuples naturally have a boxing conversion. Importantly, the names aren't part of the runtime representation of tuples, but are tracked only by the compiler. Thus, once you've "cast away" the names, you cannot recover them. In alignment with the identity conversions, a boxed tuple will unbox to any tuple type that has the same element types in the same order.
-
-## Target typing
-
-A tuple literal is "target typed" whenever possible. What that means is that the tuple literal has a "conversion from expression" to any tuple type, as long as the element expressions of the tuple literal have an implicit conversion to the element types of the tuple type.
-
-``` c#
-(string name, byte age) t = (null, 5); // Ok: the expressions null and 5 convert to string and byte
-```
-
-In cases where the tuple literal is not part of a conversion, it acquires its "natural type", which means a tuple type where the element types are the types of the constituent expressions. Since not all expressions have types, not all tuple literals have a natural type either:
-
-``` c#
-var t = ("John", 5); // Ok: the type of t is (string, int)
-var t = (null, 5); // Error: null doesn't have a type
-```
-
-A tuple literal may include names, in which case they become part of the natural type:
-
-``` c#
-var t = (name: "John", age: 5); // The type of t is (string name, int age)
-```
-
-## Conversion propagation
-
-A harder question is whether tuple types should be convertible to each other based on conversions between their element types. Intuitively it seems that implicit and explicit conversions should just "bleed through" and compose to the tuples. This leads to a lot of complexity and hard questions, though. What kind of conversion is the tuple conversion? Different places in the language place different restrictions on which conversions can apply - those would have to be "pushed down" as well.
-
-``` c#
-var t1 = ("John", 5); // (string, int)
-(object, long) t2 = t1; // What kind of conversion is this? Where is it allowed
-```
-
-On the whole we think that, while intuitive, the need for such conversions isn't actually that common. It's hard to construct an example that isn't contrived, involving for instance tuple-typed method parameters and the like. When you really need it, you can deconstruct the tuple and reconstruct it with a tuple literal, making use of target typing.
-
-We'll keep an eye on it, but for now the decision is *not* to propagate element conversions through tuple types. We do recognize that this is a decision we don't get to change our minds on once we've shipped: adding conversions in a later version would be a significant breaking change.
-
-## Projection initializers
-
-Tuple literals are a bit like anonymous types. The latter have "projection initializers" where if you don't specify a member name, one will be extracted from the given expression, if possible. Should we do that for tuples too?
-
-``` c#
-var a = new { Name = c.FirstName, c.Age }; // Will have members Name and Age
-var t = (Name: c.FirstName, c.Age); // (string Name, int Age) or error?
-```
-
-We don't think so. The difference is that names are optional in tuples. It'd be too easy to pick up a random name by mistake, or get errors because two elements happen to pick up the same name.
-
-## Extension methods on tuples
-
-This should just work according to existing rules. That means that extension methods on a tuple type apply even to tuples with different element names:
-
-``` c#
-static void M(this (int x, int y) t) { ... }
-
-(int a, int b) t = ...;
-t.M(); // Sure
-```
-
-## Default parameters
-
-Like other types, you can use `default(T)` to specify a default parameter of tuple type. Should you also be allowed to specify a tuple literal with suitably constant elements?
-
-``` c#
-void M((string, int) t = ("Bob", 7)) { ... } // Allowed?
-```
-
-No. We'd need to introduce a new attribute for this, and we don't even know if it's a useful scenario.
-
-## Syntax for 0-tuples and 1-tuples?
-
-We lovingly refer to 0-tuples as nuples, and 1-tuples as womples. There is already an underlying `ValueTuple` of size one. We should will also have the non-generic `ValueTuple` be an empty struct rather than a static class.
-
-The question is whether nuples and womples should have syntactic representation as tuple types and literals? `()` would be a natural syntax for nuples (and would no doubt find popularity as a "unit type" alternative to `void`), but womples are harder: parenthesized expressions already have a meaning!
-
-We made no final decisions on this, but won't pursue it for now.
-
-## Return tuple members directly in scope
-
-There is an idea to let the members of a tuple type appearing in a return position of a method be in scope throughout the method:
-
-``` c#
-(string first, string last) GetName()
-{
- first = ...; last = ...; // Assign the result directly
- return; // No need to return an explicit value
-}
-```
-
-The idea here is to enhance the symmetry between tuple types and parameter lists: parameter names are in scope, why should "result names"?
-
-This is cute, but we won't do it. It is too much special casing for a specific placement of tuple types, and it is also actually preferable to be able to see exactly what is returned at a given `return` statement.
-
-
-# Integrating pattern matching with is-expressions and switch-statements
-For pattern matching to feel natural in C# it is vital that it is deeply integrated with existing related features, and does in fact take its queues from how they already work. Specifically we want to extend is-expressions to allow patterns where today they have types, and we want to augment switch-statements so that they can switch on any type, use patterns in case-clauses and add additional conditions to case-clauses using when-clauses.
-
-This integration is not always straightforward, as witnessed by the following issues. In each we need to decide what patterns should *generally* do, and mitigate any breaking changes this would cause in currently valid code.
-
-
-## Name lookup
-
-The following code is legal today:
-
-``` c#
-if (e is X) {...}
-switch(e) { case X: ... }
-```
-
-We'd like to extend both the places where `X` occurs to be patterns. However, `X` means different things in those two places. In the `is` expression it must refer to a type, whereas in the `case` clause it must refer to a constant. In the `is` expression we look it up as a type, ignoring any intervening members called `X`, whereas in the `case` clause we look it up as an expression (which can include a type), and give an error if the nearest one found is not a constant.
-
-As a pattern we think `X` should be able to both refer to a type and a constant. Thus, we prefer the `case` behavior, and would just stop giving an error when `case X:` refers to a type. For `is` expressions, to avoid a breaking change, we will first look for just a type (today's behavior), and if we don't find one, rather than error we will look again for a constant.
-
-## Conversions in patterns
-
-An `is` expression today will only acknowledge identity, reference and boxing conversions from the run-time value to the type. It looks for "the actual" type, if you will, without representation changes:
-
-``` c#
-byte b = 5;
-WriteLine(b is byte); // True: identity conversion
-WriteLine((object)b is byte); // True: boxing conversion
-WriteLine((object)b is object); // True: reference conversion
-WriteLine(b is int); // False: numeric conversion changes representation
-```
-
-This seems like the right semantics for "type testing", and we want those to carry over to pattern matching.
-
-Switch statements are more weird here today. They have a fixed set of allowed types to switch over (primitive types, their nullable equivalents, strings). If the expression given has a different type, but has a unique implicit conversion to one of the allowed ones, then that conversion is applied! This occurs mainly (only?) when there is a user defined conversion from that type to the allowed one.
-
-That of course is intended only for constant cases. It is not consistent with the behavior we want for type matching per the above, and it is also not clear how to generalize it to switch expressions of arbitrary type. It is behavior that we want to limit as much as possible.
-
-Our solution is that in switches *only* we will apply such a conversion on the incoming value *only* if all the cases are constant. This means that if you add a non-constant case to such a switch (e.g. a type pattern), you will break it. We considered more lenient models involving applying non-constant patterns to the *non*-converted input, but that just leads to weirdness, and we don't think it's necessary. If you *really* want your conversion applied, you can always explicitly apply it to the switch expression yourself.
-
-
-## Pattern variables and multiple case labels
-
-C# allows multiple case labels on the same body. If patterns in those case labels introduce variables, what does that mean?
-
-``` c#
-case int i:
-case byte b:
- WriteLine("Integral value!");
- break;
-```
-
-Here's what it means: The variables go into the same declaration space, so it is an error to introduce two of the same name in case clauses for the same body. Furthermore, the variables introduced are not definitely assigned, because the given case clause assigns them, and you didn't necessarily come in that way. So the above example is legal, but the body cannot read from the variables `i` and `b` because they are not definitely assigned.
-
-It is tempting to consider allowing case clauses to share variables, so that they could be extracted from similar but different patterns:
-``` c#
-case (int age, string name):
-case (string name, int age):
- WriteLine($"{name} is {age} years old.");
- break;
-```
-
-We think that is way overboard right now, but the rules above preserve our ability to allow it in the future.
-
-## Goto case
-
-It is tempting to ponder generalizations of `goto case x`. For instance, maybe you could do the whole switch again, but on the value `x`. That's interesting, but comes with lots of complications and hidden performance traps. Also it is probably not all that useful.
-
-Instead we just need to preserve the simple meaning of `goto case x` from current switches: it's allowed if `x` is constant, if there's a case with the same constant, and that case doesn't have a `when` clause.
-
-## Errors and warnings
-
-Today `3 is string` yields a warning, while `3 as string` yields and error. They philosophy seems to be that the former is just asking a question, whereas the other is requesting a value. Generalized `is` expressions like `3 is string s` are sort of a combination of `is` and `as`, both answering the question and (conditionally) producing a value. Should they yield warnings or errors?
-
-We didn't reach consensus and decided to table this for later.
-
-## Constant pattern equality
-
-In today's `switch` statement, the constants in labels must be implicitly convertible to the governing type (of the switch expression). The equality is then straightforward - it works the same as the `==` operator. This means that the following case will print `Match!`.
-
-``` c#
-switch(7)
-{
- case (byte)7:
- WriteLine("Match!");
- break;
-}
-```
-
-What should be the case if we switch on something of type object instead?:
-
-``` c#
-switch((object)7)
-{
- case (byte)7:
- WriteLine("Match!");
- break;
-}
-```
-
-One philosophy says that it should work the same way regardless of the static type of the expression. But do we want constant patterns everywhere to do "intelligent matching" of integral types with each other? That certainly leads to more complex runtime behavior, and would probably require calling helper methods. And what of other related types, such as `float` and `double`? There isn't similar intelligent behavior you can do, because the representations of most numbers will differ slightly and a number such as 2.1 would thus not be "equal to itself" across types anyway.
-
-The other option is to make the behavior different depending on the compile-time type of the expression. We'll use integral equality only if we know statically which one to pick, because the left hand side was also known to be integral. That would preserve the switch behavior, but make the pattern's behavior dependent on the static type of the expression.
-
-For now we prefer the latter, as it is simpler.
-
-
-# Recursive patterns
-
-There are several core design questions around the various kinds of recursive patterns we are envisioning. However, they seem to fall in roughly two categories:
-
-1. Determine the syntactic shape of each recursive pattern in itself, and use that to ensure that the places where patterns can occur are syntactically well-formed and unambiguous.
-2. Decide exactly how the patterns work, and what underlying mechanisms enable them.
-
-This is an area to focus more on in the future. For now we're just starting to dig in.
-
-## Recursive pattern syntax
-
-For now we envision three shapes of recursive patterns
-
-1. Property patterns: `Type { Identifier_1 is Pattern_1, ... , Identifier_n is Pattern_n }`
-2. Tuple patterns: `(Pattern_1, ... Pattern_n)`
-3. Positional patterns: `Type (Pattern_1, ... Pattern_n)`
-
-There's certainly room for evolution here. For instance, it is not lost on us that 2 and 3 are identical except for the presence of a type in the latter. At the same time, the presence of a type in the latter seems syntactically superfluous in the cases where the matched expression is already known to be of that type (so the pattern is used purely for deconstruction and/or recursive matching of the elements). Those two observations come together to suggest a more orthogonal model, where the types are optional:
-
-1. Property patterns: `Type_opt { Identifier_1 is Pattern_1, ... , Identifier_n is Pattern_n }`
-2. Positional patterns: `Type_opt (Pattern_1, ... Pattern_n)`
-
-In this model, what was called "tuple patterns" above would actually not just apply to tuples, but to anything whose static type (somehow) specifies a suitable deconstruction.
-
-This is important because it means that "irrefutable" patterns - ones that are known to always match - never need to specify the type. This in turn means that they can be used for unconditional deconstruction even in syntactic contexts where positional patterns would be ambiguous with invocation syntax. For instance, we could have what would amount to a "deconstruction" variant of a declaration statement, that would introduce all its match variables into scope as local variables for subsequent statements:
-
-``` c#
-(string name, int age) = GetPerson(); // Unconditional deconstruction
-WriteLine($"{name} is {age} years old"); // name and age are in scope
-
-```
-
-## How recursive patterns work
-
-Property patterns are pretty straightforward - they translate into access of fields and properties.
-
-Tuple patterns are also straightforward if we decide to handle them specially.
-
-Positional patterns are more complex. We agree that they need a way to be specified, but the scope and mechanism for this is still up for debate. For instance, the `Type` in the positional pattern may not necessarily trigger a type test on the object. Instead it may name a class where a more general "matcher" is defined, which does its own tests on the object. This could be complex stuff, like picking a string apart to see if it matches a certain format, and extracting certain information from it if so.
-
-The syntax for declaring such "matchers" may be methods, or a new kind of user defined operator (like `is`) or something else entirely. We still do not have consensus on either the scope or shape of this, so there's some work ahead of us.
-
-The good news is that we can add pattern matching in several phases. There can be a version of C# that has pattern matching with none or only some of the recursive patterns working, as long as we make sure to "hold a place for them" in the way we design the places where patterns can occur. So C# 7 can have great pattern matching even if it doesn't yet have *all* of it.
-
\ No newline at end of file
diff --git a/docs/features/NullableReferenceTypes/ImplementationNotes.md b/docs/features/NullableReferenceTypes/ImplementationNotes.md
new file mode 100644
index 0000000000000..67f0d7b86a0de
--- /dev/null
+++ b/docs/features/NullableReferenceTypes/ImplementationNotes.md
@@ -0,0 +1,172 @@
+Implicit type declarations:
+- Properties of anonymous types are considered nullable if their type is a reference type.
+- Element type of an array created by implicitly typed array creation expression is considered nullable if the type is a reference type.
+- Type of a var local is considered nullable if the type is a reference type.
+
+For the purpose of flow analysis, result of expression can have three states:
+- Assumed to have not null value.
+- Possibly has null value.
+- Unknown nullability (no diagnostics is derived from this state). For example, this state can arise from usage of an API that hasnt been annotated yet.
+
+Tracking state of
+- Locals
+- Parameters
+- Fields of structures
+- Anonymous Type properties
+
+The goal is to track state of the same entities, which are tracked by Definite Assignment, plus state of properties of Anonymous Types.
+
+Warn about possible null reference on
+- An assignment to a local statically typed as not-nullable.
+- An assignment to a parameter statically typed as not-nullable.
+- An assignment to a field statically typed as not-nullable.
+- An assignment to a property statically typed as not-nullable.
+- An assignment to an indexer statically typed as not-nullable.
+- An assignment to an array element statically typed as not-nullable.
+- A member initializer for a member statically typed as not-nullable.
+- An argument passed to a parameter statically typed as not-nullable.
+- An argument (local, parameter, field, array element) statically typed as not-nullable passed as ref/out to a parameter statically typed as nullable.
+- A return expression if return type of the method is statically typed as not-nullable.
+- A receiver of a method/field/property/indexer access.
+- An array expression of an array access.
+
+A local is considered to have a not null value if the local is statically typed as not-nullable, or the last value assigned to the field was not null.
+
+A parameter is considered to have a not null value if the parameter is statically typed as not-nullable, or the last value assigned to the parameter was not null and the parameter is not ref/out.
+
+A field is considered to have a not null value if the field is statically typed as not-nullable, or the field is tracked by the flow analysis and the last value assigned to the field was not null.
+
+A property is considered to have a not null value if the property is statically typed as not-nullable, or the property is tracked by the flow analysis (readonly auto-property of a structure in its constructor, or a property of an Anonymous Type) and the last value assigned to the property was not null.
+
+Result of an indexer access is considered to be a not null value if the indexer is statically typed as not-nullable.
+
+Result of a method call is considered to be a not null value if its return type is statically typed as not-nullable.
+
+Passing a tracked structure or a tracked Anonymous Type instance by reference invalidates accumulated tracking information for their members.
+
+When a built-in or a user-defined operator ==/!= is used to compare an expression to a null value.
+For the purpose of flow analysis, a trackable expression is considered to be not null when == evaluates to false, or != evaluates to true. ~~If, according to flow analysis, the expression has a not null value before the operator is evaluated, a warning is reported that result of the comparison is always false (==), or always true (!=).~~
+
+When expression is used as a left operand of a Null Coalescing Operator (??).
+~~For the purpose of flow analysis, a trackable expression is considered to be null before the right operand is evaluated.~~ ~~If, according to flow analysis, the expression has a not null value before the operator is evaluated, a warning is reported that the operand is never null.~~ Result of the operator is considered to be not null for the purpose of the flow analysis if either operand is considered to be not null.
+
+When expression is used as a receiver of a conditional access (?./?[]).
+For the purpose of flow analysis, a trackable expression is considered to be not null before the access is evaluated. ~~If, according to flow analysis, the expression has a not null value before the receiver is evaluated, a warning is reported that the receiver is never null.~~ Result of the operator is considered to be not null for the purpose of the flow analysis only if both, the receiver and the access are considered to be not null.
+
+Right now, some overriding cases can be ambiguous because constraints are not specified on an overriding method, but rather inherited from the overridden method. For example:
+```
+class A
+{
+ public virtual void M1(T? x) where T : struct
+ {
+ }
+
+ public virtual void M1(T? x) where T : class
+ {
+ }
+}
+
+class B : A
+{
+ public override void M1(T? x)
+ {
+ }
+}
+```
+
+Current implementation doesn't detect this ambiguity case and simply grabs the first applicable candidate for overriding, always in in declaration order, I assume.
+
+Array type syntax is extended as follows to allow nullable modifiers:
+- string?[] x1; // not-nullable one-dimensional array of nullable strings
+- string?[]? x2; // nullable one-dimensional array of nullable strings
+- string[]? X3; // nullable one-dimensional array of not-nullable strings
+- string?[][,] x4; // not-nullable one-dimensional array of not-nullable two-dimensional arrays of nullable strings
+- string?[][,]? X5; // not-nullable one-dimensional array of nullable two-dimensional arrays of nullable strings
+- string?[]?[,] x6; // nullable one-dimensional array of not-nullable two-dimensional arrays of nullable strings
+
+Warnings are reported when there is a signature mismatch with respect to nullability of reference types during overriding,
+interface implementing, or partial method implementing.
+
+
+**NullableAttribute**
+NullableAttribute is applied to a module if it utilizes Nullable Reference Types feature.
+NullableAttribute is applied to other targets in the module to point to specific nullable reference types in type references.
+The attribute is applied in the same fashion as DynamicAttribute, with the following exceptions:
+- For types of events, it is applied to event declarations (not just to parameters of accessors).
+- Types used as custom modifiers, do not have dedicated transform flags.
+
+Here is the definition of the NullableAttribute required for the successful compilation:
+```
+namespace System.Runtime.CompilerServices
+{
+ [AttributeUsage(AttributeTargets.Event | // The type of the event is nullable, or has a nullable reference type as one of its constituents
+ AttributeTargets.Field | // The type of the field is a nullable reference type, or has a nullable reference type as one of its constituents
+ AttributeTargets.GenericParameter | // The generic parameter is a nullable reference type
+ AttributeTargets.Module | // Nullable reference types in this module are annotated by means of NullableAttribute applied to other targets in it
+ AttributeTargets.Parameter | // The type of the parameter is a nullable reference type, or has a nullable reference type as one of its constituents
+ AttributeTargets.ReturnValue | // The return type is a nullable reference type, or has a nullable reference type as one of its constituents
+ AttributeTargets.Property | // The type of the property is a nullable reference type, or has a nullable reference type as one of its constituents
+ AttributeTargets.Class , // Base type has a nullable reference type as one of its constituents
+ AllowMultiple = false)]
+ public class NullableAttribute : Attribute
+ {
+ public NullableAttribute() { }
+ public NullableAttribute(bool[] transformFlags)
+ {
+ }
+ }
+}
+```
+
+
+**Opting in and opting out of nullability warnings**
+
+It is possible to suppress all nullability warnings originating from declarations in certain referenced
+assembly by applying the following attribute:
+```
+namespace System.Runtime.CompilerServices
+{
+ ///
+ /// Opt out of nullability warnings that could originate from definitions in the given assembly.
+ /// The attribute is not preserved in metadata and ignored if present in metadata.
+ ///
+ [AttributeUsage(AttributeTargets.Module, AllowMultiple = true)]
+ class NullableOptOutForAssemblyAttribute : Attribute
+ {
+ /// An assembly name - a simple name plus its PublicKey, if any.""/>
+ public NullableOptOutForAssemblyAttribute(string assemblyName) { }
+ }
+}
+```
+
+It is possible to apply the following attribute to a declaration itself in order to opt in or opt out all consumers
+from nullability warnings originating from the declaration.
+The attribute can be applied to a module, type, method, event, field or property. The closest attribute application wins.
+If nullable reference types feature is enabled, the warnings are opted into on the module level by default, i.e.
+explicit attribute application is not needed in this case.
+When a method definition is opted out of the warnings, nullablility warnings in its method body are also suppressed.
+
+```
+namespace System.Runtime.CompilerServices
+{
+ ///
+ /// Opt-out or opt into nullability warnings that could originate from source code and definition(s) ...
+ ///
+ [AttributeUsage(AttributeTargets.Module | // in this module. If nullable reference types feature is enabled, the warnings are opted into on the module level by default
+ AttributeTargets.Class | // in this class
+ AttributeTargets.Constructor | // of this constructor
+ AttributeTargets.Delegate | // of this delegate
+ AttributeTargets.Event | // of this event
+ AttributeTargets.Field | // of this field
+ AttributeTargets.Interface | // in this interface
+ AttributeTargets.Method | // of this method
+ AttributeTargets.Property | // of this property
+ AttributeTargets.Struct, // in this structure
+ AllowMultiple = false)]
+ class NullableOptOutAttribute : Attribute
+ {
+ public NullableOptOutAttribute(bool flag = true) { }
+ }
+}
+```
+
diff --git a/docs/features/NullableReferenceTypes/Nullable reference types.md b/docs/features/NullableReferenceTypes/Nullable reference types.md
new file mode 100644
index 0000000000000..52e759692968b
--- /dev/null
+++ b/docs/features/NullableReferenceTypes/Nullable reference types.md
@@ -0,0 +1,137 @@
+# Proposal: Static null checking in C#
+
+Null reference exceptions are rampant in languages like C\#, where any reference type can reference a null value. Some type systems separate types into a `T` that cannot be null and an `Option` (or similar) that can be null but cannot be dereferenced without an explicit null check that unpacks the non-null value.
+
+This approach is attractive, but is difficult to add to a language where every type has a default value. For instance, a newly created array will contain all nulls. Also, such systems are notorious for problems around initialization and cyclic data structures, unless non-null types are permitted to at least temporarily contain null.
+
+On top of these issues come challenges stemming from the fact that C\# already has null-unsafe types, that allow both null values and dereferencing. How can a safer approach be added to the language without breaking changes, without leaving the language more complex than necessary and with a natural experience for hardening existing code against null errors in your own time?
+
+# Approach: Nullable reference types plus nullability warnings
+
+The approach suggested here consists of a couple of elements:
+
+* Add a notion of safe nullable reference types `T?` to the language, in addition to the current ones `T` which we will now call non-nullable.
+* Detect and warn on cases where nullable types are dereferenced, or when null is values are assigned to (or left in) non-nullable variables.
+* Offer opt-in means to deal with breaking behavior and compat across versions and assemblies.
+
+The feature will not provide airtight guarantees, but should help find most nullability errors in code. It can be assumed that most values are intended *not* to be null, so this scheme provides the minimal annotation overhead.
+
+Nullable reference types are helpful, in that they help find code that may dereference null and help guard it with null checks. Non-nullability warnings are helpful in that they help prevent variables from inadvertently containing an null value.
+
+# Nullable and non-nullable reference types
+
+For every non-nullable reference type `T`, there is now a corresponding nullable reference type `T?`.
+
+Syntactically speaking, this doesn't add much, since nullable value types have the same syntax. However, a few syntactic corner cases are new, like `T[]?`.
+
+From a semantic viewpoint, `T` and `T?` are equivalent in every way: they are the same type. The *only* way in which they differ is in the warnings caused by their use.
+
+For type inference purposes `T` and `T?` are considered the same type. If a reference type `T` is the result of type inference, and at least one of the candidate reference types is nullable, then the result is nullable too.
+
+If an expression is by declaration of type `T?`, it will still be considered to be of type `T` if it occurs in a context where by flow analysis we consider it known that it is not null.
+
+## Warnings for nullable reference types
+
+Values of nullable reference types should not be used in a connection where a) they are not known to (probably) contain a non-null value and b) the use would require them to be non-null. Such uses will be flagged with a warning.
+
+a) means that a flow analysis has determined that they are very likely to not be null. There will be specific rules for this flow analysis, similar to those for definite assignment. It is an open question which variables are tracked by this analysis. Just locals and parameters? All dotted names?
+
+b) means dereferencing (e.g. with dot or invocation) or implicitly converting to a non-nullable reference type.
+
+## Warnings for non-nullable reference types
+
+Variables of non-nullable reference types should not be assigned the literal `null` or `default(T)`; nor should nullable value types be boxed to them. Such uses will result in a warning.
+
+Additionally, fields of non-nullable reference type must be protected by their constructor so that they are a) not used before they are assigned, and b) assigned before the constructor returns. Otherwise a warning is issued. (As an alternative to (a) we can consider allowing use before assignment, but in that case treating the variable as nullable.)
+
+Note that there is no warning to prevent new arrays of non-nullable reference type from keeping the null elements they are initially created with. There is no good static way to ensure this. We *could* consider a requirement that *something* must be done to such an array before it can be read from, assigned or returned; e.g. there must be at least one element assignment to it, or it must be passed as an argument to something that could potentially initialize it. That would at least catch the situation where you simply forgot to initialize it. But it is doubtful that this has much value.
+
+# Generics
+
+Constraints can be both nullable and non-nullable. The default constraint for an unconstrained type parameter is `object?`.
+
+A warning is issued if a type parameter with at least one non-nullable reference constraint is instantiated with a nullable reference type.
+
+A type parameter with at least one non-nullable constraint is treated as a non-nullable type in terms of warnings given.
+
+A type parameter with no non-nullable reference constraints is treated as *both* a nullable *and* a non-nullable reference type in terms of warnings given (since it could without warning have been instantiated with either). This means that *both* sets of warnings apply.
+
+`?` is allowed to be applied to any type parameter `T`. For type parameters with the `struct` constraint it has the usual meaning. For all other type parameters it has this meaning, where `S` is the type with which `T` is instantiated:
+
+* If `S` is a non-nullable reference type then `T?` refers to `S?`
+* Otherwise, `S?` refers to `S`
+
+Note: This rule is not elegant - in particular it is bad that the introduction of a `struct` constraint changes the meaning of `?`. But we believe we need it to faithfully express the type of common APIs such as `FirstOrDefault()`.
+
+## Opting in and opting out
+
+Some of the nullability warnings warn on code that exists without warnings today. There should be a way of opting out of those nullability warnings for compatibility purposes.
+
+When opting *in*, assemblies generated should contain an assembly-level attribute with the purpose of signalling that nullable and non-nullable types in signatures should generate appropriate warnings in consuming code.
+
+When consuming code references an assembly that does *not* have such a top-level attribute, the types in that assembly should be treated as *neither* nullable *nor* non-nullable. That is, neither set of warnings should apply to those types.
+
+This mechanism exists such that code that was not written to work with nullability warnings, e.g. code from a previous version of C\#, does indeed not trigger such warnings. Only assemblies that opt in by having the compiler-produced attribute, will cause the nullability warnings to happen in consuming code accessing their signatures.
+
+When warnings haven't been opted in to, the compiler should give some indication that there are likely bugs one would find by opting in. For instance, it could give (as an informational message, not a warning) a count of how many nullability warnings it would have given.
+
+Even when a library has opted in, consuming code may be written with an earlier version of C\#, and may not recognize the nullability annotations. Such code will work without warning. To facilitate smooth upgrade of the consuming code, it should probably be possible to opt out of the warnings from *a given* library that will now start to occur. Again, such per-assebly opt-out could be accompanied by an informational message reminding that nullability bugs may be going unnoticed.
+
+# Libraries and compatibility
+
+An example: In my C\# client code, I use libraries A and B:
+
+``` c#
+// library A
+public class A
+{
+ public static string M(string s1, string s2);
+}
+
+// library B
+public class B
+{
+ public static object N(object o1, object o2);
+}
+
+// client C, referencing A and B
+Console.WriteLine(A.M("a", null).Length);
+Console.WriteLine(B.N("b", null).ToString());
+```
+
+Now library B upgrades to C\# 7, and starts using nullability annotations:
+
+``` c#
+// upgraded library B
+public class B
+{
+ public static object? N(object o1, object o2); // o1 and o2 not supposed to be null
+}
+
+```
+
+It is clear that my client code probably has a bug: apparently it was not supposed to pass null to B.N. However, the C\# 6 compiler knows nothing of all this, and ignores the assembly-level attribute opting in to it.
+
+Now I upgrade to C\# 7 and start getting warnings on my call to B.N: the second argument shouldn't be null, and I shouldn't dot into the return value without checking it for null. It may not be convenient for me to look at those potential bugs right now; I just want a painless upgrade. So I can opt out of getting nullability warnings at all, or for that specific assembly. On compile, I am informed that I may have nullability bugs, so I don't forget to turn it on later.
+
+Eventually I do, I get my warnings and I fix my bugs:
+
+``` c#
+Console.WriteLine(B.N("b", "")?.ToString());
+```
+
+Passing the empty string instead of null, and using the null-conditional operator to test the result for null.
+
+Now the owner of library A decides to add nullability annotations:
+
+``` c#
+// library A
+public class A
+{
+ public static string? M(string s1, string s2); // s1 and s2 shouldn't be null
+}
+```
+
+As I compile against this new version, I get new nullability warnings in my code. Again, I may not be ready for this - I may have upgraded to the new version of the library just for bug fixes - and I may temporarily opt out for that assembly.
+
+In my own time, I opt it in, get my warnings and fix my code. I am now completely in the new world. During the whole process I never got "broken" unless I asked for it with some explicit gesture (upgrade compiler or libraries), and was able to opt out if I wasn't ready. When I did opt in, the warnings told me that I used a library against its intentions, so fixing those places probably addressed a bug.
\ No newline at end of file
diff --git a/docs/features/NullableReferenceTypes/README.md b/docs/features/NullableReferenceTypes/README.md
new file mode 100644
index 0000000000000..f2a4a2cbacbd9
--- /dev/null
+++ b/docs/features/NullableReferenceTypes/README.md
@@ -0,0 +1,45 @@
+## Testing `features/NullableReferenceTypes` in Visual Studio 2017
+_Install is available for Visual Studio versions 15.3 and 15.4 only. Installing on 15.5 or later is **not** supported currently._
+
+### Installing Roslyn extension
+1. Start Visual Studio 2017
+2. Go to Tools: Options: Extensions and Updates
+
+![tools-options](https://user-images.githubusercontent.com/10732005/30494467-10c33ff8-99fd-11e7-915c-7f8d7b038fdc.png)
+
+3. Click Add and enter:
+
+ Name: Roslyn Nullable
+
+ URL: https://dotnet.myget.org/F/roslyn-nonnull/vsix/
+
+4. Use the checkbox at the top to enable or disable automatically updating the extension when Visual Studio is started
+5. Click Apply and OK
+6. Go to Tools: Extensions and Updates
+
+![tools-extensions-and-updates](https://user-images.githubusercontent.com/10732005/30494782-53f7a5a6-99fe-11e7-9c1f-3b11f4a321d8.png)
+
+7. Choose Online: Roslyn Nullable: Roslyn Insiders for VS next
+8. Click Download and Close
+9. Close Visual Studio
+10. Click Modify on the VSIX Installer that starts automatically
+
+![vsix-installer](https://user-images.githubusercontent.com/10732005/30494890-bb75d504-99fe-11e7-8b3d-61545aa8e5da.png)
+
+11. After the install completes, click Close
+12. Start Visual Studio
+
+The extension should be installed.
+
+### Uninstalling Roslyn extension
+1. Start Visual Studio 2017
+2. Go to Tools: Extensions and Updates
+3. Search for Roslyn
+
+![uninstall-extension](https://user-images.githubusercontent.com/10732005/30495242-24e4271a-9a00-11e7-988b-ed71af8ba719.png)
+
+4. Click Uninstall on Roslyn Insiders for VS next
+5. Click Close
+6. Close Visual Studio
+
+The extension should be uninstalled.
diff --git a/docs/features/nullable-reference-types.md b/docs/features/nullable-reference-types.md
new file mode 100644
index 0000000000000..c97224444b888
--- /dev/null
+++ b/docs/features/nullable-reference-types.md
@@ -0,0 +1,265 @@
+Nullable Reference Types
+=========
+Reference types may be nullable, non-nullable, or null-oblivious (abbreviated here as `?`, `!`, and `~`).
+
+## Annotations
+In source, nullable reference types are annotated with `?`.
+```c#
+string? OptString; // may be null
+Dictionary? OptDictionaryOptValues; // dictionary may be null, values may be null
+```
+A warning is reported when annotating a reference type or unconstrained generic type with `?` outside a `NonNullTypes(true)` context.
+
+In metadata, nullable reference types are annotated with a `[Nullable]` attribute.
+```c#
+namespace System.Runtime.CompilerServices
+{
+ [AttributeUsage(
+ AttributeTargets.Class |
+ AttributeTargets.GenericParameter |
+ AttributeTargets.Event | AttributeTargets.Field | AttributeTargets.Property |
+ AttributeTargets.Parameter | AttributeTargets.ReturnValue,
+ AllowMultiple = false)]
+ public sealed class NullableAttribute : Attribute
+ {
+ public NullableAttribute() { }
+ public NullableAttribute(bool[] b) { }
+ }
+}
+```
+The parameter-less constructor is emitted for simple type references with top-level nullability and for type parameter definitions that have a `class?` constraint;
+the constructor with `bool[]` parameter is emitted for type references with nested types and nullability.
+```c#
+// C# representation of metadata
+[Nullable]
+string OptString; // string?
+[Nullable(new[] { true, false, true })]
+Dictionary OptDictionaryOptValues; // Dictionary?
+```
+The `NullableAttribute` type declaration is synthesized by the compiler if it is not included in the compilation.
+
+Unannotated reference types are non-nullable or null-oblivious depending on whether the containing scope includes `[NonNullTypes]`.
+```c#
+namespace System.Runtime.CompilerServices
+{
+ [AttributeUsage(AttributeTargets.Class |
+ AttributeTargets.Constructor |
+ AttributeTargets.Delegate |
+ AttributeTargets.Enum |
+ AttributeTargets.Event |
+ AttributeTargets.Field |
+ AttributeTargets.Interface |
+ AttributeTargets.Method |
+ AttributeTargets.Module |
+ AttributeTargets.Property |
+ AttributeTargets.Struct,
+ AllowMultiple = false)]
+ internal sealed class NonNullTypesAttribute : Attribute
+ {
+ public NonNullTypesAttribute(bool enabled = true) { }
+ }
+}
+```
+If there is no `[NonNullTypes]` attribute at any containing scope, including the module, reference types are null-oblivious.
+```c#
+[NonNullTypes(false)] string[] Oblivious; // string~[]~
+[NonNullTypes(true)] string[] NotNull; // string![]!
+[NonNullTypes(false), Nullable(new[] { false, true })] string[] ObliviousMaybeNull; // string?[]~
+[NonNullTypes(true), Nullable(new[] { false, true })] string[] NotNullMaybeNull; // string?[]!
+```
+The `NonNullTypesAttribute` is always implicitly included in a compilation, but is only emitted if it is referenced in source. It cannot be referenced from metadata (assembly or module).
+`NonNullTypesAttribute` can only be used in C# 8.0 compilations (or above).
+
+## Declaration warnings
+_Describe warnings reported for declarations in initial binding._
+
+## Flow analysis
+Flow analysis is used to infer the nullability of variables within executable code. The inferred nullability of a variable is independent of the variable's declared nullability.
+Method calls are analyzed even when they are conditionally omitted. For instance, `Debug.Assert` in release mode.
+
+### Warnings
+_Describe set of warnings. Differentiate W warnings._
+If the analysis determines that a null check always (or never) passes, a hidden diagnostic is produced. For example: `"string" is null`.
+
+### Null tests
+A number of null checks affect the flow state when tested for:
+- comparisons to `null`: `x == null` and `x != null`
+- `is` operator: `x is null`, `x is K` (where `K` is a constant), `x is string`, `x is string s`
+
+Invocation of methods annotated with the following attributes will also affect flow analysis:
+- `[NotNullWhenTrue]` (e.g. `TryGetValue`) and `[NotNullWhenFalse]` (e.g. `string.IsNullOrEmpty`)
+- `[EnsuresNotNull]` (e.g. `ThrowIfNull`)
+- `[AssertsTrue]` (e.g. `Debug.Assert`) and `[AssertsFalse]`
+
+## `default`
+`default(T)` is `T?` if `T` is a reference type.
+_Is `default(T)` also `T?` if `T` is an unconstrained type parameter?_
+_Is `default(T?)` an error?_
+```c#
+string? s = default(string); // assigns ?, no warning
+string t = default; // assigns ?, warning
+T t = default; // assigns ?, warning
+```
+
+### Conversions
+_Describe valid top-level and variance conversions._
+_Describe warnings from user-defined conversions._
+
+### Assignment
+For `x = y`, the nullability of the converted type of `y` is used for `x`.
+A warning is reported if there is a mismatch between top-level or nested nullability comparing the inferred nullability of `x` and the declared type of `y`.
+The warning is a W warning when assigning `?` to `!` and the target is a local.
+```c#
+notNull = maybeNull; // assigns ?, warning
+notNull = oblivious; // assigns ~, no warning
+oblivious = maybeNull; // assigns ?, no warning
+```
+
+### Local declarations
+Nullablilty follows from assignment above. Assigning `?` to `!` is a W warning.
+```c#
+string notNull = maybeNull; // assigns ?, warning
+```
+Nullability of `var` declarations is determined from flow analysis.
+```c#
+var s = maybeNull; // s is ?, no warning
+if (maybeNull == null) return;
+var t = maybeNull; // t is !
+```
+
+### Suppression operator (`!`)
+The postfix `!` operator sets the top-level nullability to non-nullable.
+```c#
+var x = optionalString!; // x is string!
+var y = obliviousString!; // y is string!
+var z = new [] { optionalString, obliviousString }!; // no change, z is string?[]!
+```
+An error is reported whenever the `!` operator is applied to a value type.
+A warning is reported when using the `!` operator absent a `NonNullTypes` context.
+
+_Should `!` suppress warnings for nested nullability?_
+_Should `nonNull!` result in a warning for unnecessary `!`?_
+_Should `!!` be an error?_
+
+### Explicit cast
+Explicit cast to `?` changes top-level nullability.
+Explicit cast to `!` does not change top-level nullability and may produce W warning.
+```c#
+var x = (string)maybeNull; // x is string?, W warning
+var y = (string)oblivious; // y is string~, no warning
+var z = (string?)notNull; // y is string?, no warning
+```
+A warning is reported if the type of operand including nested nullability is not explicitly convertible to the target type.
+```c#
+sealed class MyList : IEnumerable { }
+var x = new MyList();
+var y = (IEnumerable