From 131475457f057757eb81d99076354a314c745a5e Mon Sep 17 00:00:00 2001 From: Nikita Potapenko Date: Sat, 16 Mar 2019 09:38:13 +0000 Subject: [PATCH] Fix typo .Net - .NET --- docs/analyzers/Localizing Analyzers.md | 2 +- .../Overflow In Embedded Runtime.md | 2 +- ...ding, Debugging, and Testing on Windows.md | 2 +- docs/features/deconstruction.md | 2 +- .../Portable/CodeGen/EmitArrayInitializer.cs | 2 +- .../Portable/Compilation/CSharpCompilation.cs | 2 +- .../Symbol/Compilation/CompilationAPITests.cs | 2 +- .../Symbols/Metadata/PE/TypeForwarders.cs | 2 +- .../Test/Symbol/Symbols/SymbolErrorTests.cs | 2 +- .../CSharp/Test/Symbol/Symbols/TypeTests.cs | 4 +- .../Core/MSBuildTask/ManagedToolTask.cs | 2 +- .../InternalUtilities/StringExtensions.cs | 2 +- .../Portable/CodeGen/EmitArrayInitializer.vb | 2 +- .../Compilation/VisualBasicCompilation.vb | 2 +- .../Metadata/PE/TypeForwarders.vb | 4 +- .../Symbol/SymbolsTests/Source/TypeTests.vb | 2 +- .../Test/Syntax/Resources/VBAllInOne.vb | 2 +- .../Test/Syntax/Syntax/VBAllInOne.txt | 2 +- ...ymousTypeToClassCodeRefactoringProvider.cs | 2 +- .../RegexEmbeddedCompletionProvider.cs | 2 +- .../AbstractGenerateTypeService.State.cs | 2 +- ...stractNavigateToSearchService.InProcess.cs | 2 +- src/Test/Utilities/Portable/TestResource.resx | 4 +- .../VisualStudioWorkspaceImpl.cs | 2 +- ...ntainedDocument.DocumentServiceProvider.cs | 2 +- .../Extensions/SimpleNameSyntaxExtensions.cs | 2 +- .../CSharpRegexParserTests.cs | 8 ++-- .../LanguageServices/RegexSyntaxClassifier.cs | 2 +- .../RegularExpressions/RegexCharClass.cs | 2 +- .../RegularExpressions/RegexLexer.cs | 2 +- .../RegularExpressions/RegexNodes.cs | 2 +- .../RegularExpressions/RegexParser.cs | 48 +++++++++---------- .../Portable/Formatting/FormattingOptions.cs | 2 +- ...yntaxTreeExtensions_SharedWithCodeStyle.cs | 2 +- .../Portable/Shared/Utilities/BloomFilter.cs | 2 +- .../Core/Portable/Utilities/TaskExtensions.cs | 2 +- .../IFrameworkAssemblyPathResolver.cs | 6 +-- 37 files changed, 68 insertions(+), 68 deletions(-) diff --git a/docs/analyzers/Localizing Analyzers.md b/docs/analyzers/Localizing Analyzers.md index da2b259756b..dd0d47b376d 100644 --- a/docs/analyzers/Localizing Analyzers.md +++ b/docs/analyzers/Localizing Analyzers.md @@ -17,7 +17,7 @@ You'll need to create a .resx file to hold your localizable resources. For the p Using Localized Resources in Analyzers -------------------------------------- -Normally, .Net applications can simply access the resource through the type generated from the .resx file: +Normally, .NET applications can simply access the resource through the type generated from the .resx file: ``` C# string message = AnalyzerResources.Message; ``` diff --git a/docs/compilers/Visual Basic/Overflow In Embedded Runtime.md b/docs/compilers/Visual Basic/Overflow In Embedded Runtime.md index c55bab1295a..71e6d227020 100644 --- a/docs/compilers/Visual Basic/Overflow In Embedded Runtime.md +++ b/docs/compilers/Visual Basic/Overflow In Embedded Runtime.md @@ -1,6 +1,6 @@ ### 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. +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() diff --git a/docs/contributing/Building, Debugging, and Testing on Windows.md b/docs/contributing/Building, Debugging, and Testing on Windows.md index 842521f5914..8d3c35ad537 100644 --- a/docs/contributing/Building, Debugging, and Testing on Windows.md +++ b/docs/contributing/Building, Debugging, and Testing on Windows.md @@ -43,7 +43,7 @@ The Test.cmd script will run our unit test on already built binaries. It can be 2. Navigate to the directory of your Git clone. 3. Run `msbuild /v:m /m /nodereuse:false BuildAndTest.proj` in the command prompt. -You can more precisely control how the tests are run by running the eng/build.ps1 script directly with the relevant options. For example passing in the `-test` switch will run the tests on .Net Framework, whilst passing in the `-testCoreClr` switch will run the tests on .Net Core. +You can more precisely control how the tests are run by running the eng/build.ps1 script directly with the relevant options. For example passing in the `-test` switch will run the tests on .NET Framework, whilst passing in the `-testCoreClr` switch will run the tests on .NET Core. The results of the tests can be viewed in the artifacts/TestResults directory. diff --git a/docs/features/deconstruction.md b/docs/features/deconstruction.md index 5da7d3045a3..8c770966c5d 100644 --- a/docs/features/deconstruction.md +++ b/docs/features/deconstruction.md @@ -73,7 +73,7 @@ If the left-hand-side is nested the process will be repeated. For instance, in ` In the case where the expression on the right is a tuple expression, it is first given a type. So in `long x; string y; (x, y) = (1, null);` the literals on the right-hand-side are typed as `long` and `string` before the deconstruction even starts, which means that no conversions will be needed during the deconstruction steps. We noted already that tuples (which are syntactic sugar for the `System.ValueTuple` underlying type) don't need to invoke `Deconstruct`. -The .Net framework also includes a set of `System.Tuple` types. Those are not recognized as C# tuples, and so will rely on the *Deconstruct* pattern. Those `Deconstruct` methods will be provided as extension methods for `System.Tuple` for up to 3 nestings deep (that is 21 elements). +The .NET framework also includes a set of `System.Tuple` types. Those are not recognized as C# tuples, and so will rely on the *Deconstruct* pattern. Those `Deconstruct` methods will be provided as extension methods for `System.Tuple` for up to 3 nestings deep (that is 21 elements). A *deconstruction-assignment* returns a tuple value (with elements using default names) which is shaped and typed like the left-hand-side and holds the (converted) parts resulting from deconstruction. diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitArrayInitializer.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitArrayInitializer.cs index 584e79bfc0c..4d6efaaeecc 100644 --- a/src/Compilers/CSharp/Portable/CodeGen/EmitArrayInitializer.cs +++ b/src/Compilers/CSharp/Portable/CodeGen/EmitArrayInitializer.cs @@ -286,7 +286,7 @@ private void InitializerCountRecursive(ImmutableArray inits, re else { // NOTE: default values do not need to be initialized. - // .Net arrays are always zero-inited. + // .NET arrays are always zero-inited. if (!init.IsDefaultValue()) { initCount += 1; diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs index a60511252b7..df9142e75e7 100644 --- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs +++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs @@ -3236,7 +3236,7 @@ internal void SymbolDeclaredEvent(Symbol symbol) /// /// In NetFx 4.0, block array initializers do not work on all combinations of {32/64 X Debug/Retail} when array elements are enums. /// This is fixed in 4.5 thus enabling block array initialization for a very common case. - /// We look for the presence of which was introduced in .Net 4.5 + /// We look for the presence of which was introduced in .NET Framework 4.5 /// internal bool EnableEnumArrayBlockInitialization { diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs index 41c6ca596db..782cb524fa1 100644 --- a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs +++ b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs @@ -2031,7 +2031,7 @@ public void AppConfig1() [Fact] public void AppConfig2() { - // Create a dll with a reference to .net system + // Create a dll with a reference to .NET system string libSource = @" using System.Runtime.Versioning; public class C { public static FrameworkName Goo() { return null; }}"; diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/TypeForwarders.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/TypeForwarders.cs index c4cf4f970fe..0ab47260d96 100644 --- a/src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/TypeForwarders.cs +++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/TypeForwarders.cs @@ -1607,7 +1607,7 @@ public class Test { } EntityHandle token = metadata.GetTypeRef(metadata.GetAssemblyRef("mscorlib"), "System.Runtime.CompilerServices", "AssemblyAttributesGoHereM"); Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there. - // Exported types in .Net module cause PEVerify to fail. + // Exported types in .NET module cause PEVerify to fail. CompileAndVerify(appCompilation, verify: Verification.Fails, symbolValidator: m => { diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs index 3ffbfc5b484..18e9c2e7f67 100644 --- a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs +++ b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs @@ -6981,7 +6981,7 @@ public class CF3 forwardedTypes1Ref }, TestOptions.ReleaseDll); - // Exported types in .Net modules cause PEVerify to fail on some platforms. + // Exported types in .NET modules cause PEVerify to fail on some platforms. CompileAndVerify(compilation, verify: Verification.Skipped).VerifyDiagnostics(); compilation = CreateCompilation("[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(CF3))]", diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/TypeTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/TypeTests.cs index 9f02654d226..be6861da15a 100644 --- a/src/Compilers/CSharp/Test/Symbol/Symbols/TypeTests.cs +++ b/src/Compilers/CSharp/Test/Symbol/Symbols/TypeTests.cs @@ -515,8 +515,8 @@ public void ArrayTypes() } // Interfaces impl-ed by System.Array - // .Net 2/3.0 (7) IList&[T] -> ICollection&[T] ->IEnumerable&[T]; ICloneable; - // .Net 4.0 (9) IList&[T] -> ICollection&[T] ->IEnumerable&[T]; ICloneable; IStructuralComparable; IStructuralEquatable + // .NET 2/3.0 (7) IList&[T] -> ICollection&[T] ->IEnumerable&[T]; ICloneable; + // .NET 4.0 (9) IList&[T] -> ICollection&[T] ->IEnumerable&[T]; ICloneable; IStructuralComparable; IStructuralEquatable // Array T[] impl IList[T] only [Fact, WorkItem(537300, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/537300"), WorkItem(527247, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/527247")] public void ArrayTypeInterfaces() diff --git a/src/Compilers/Core/MSBuildTask/ManagedToolTask.cs b/src/Compilers/Core/MSBuildTask/ManagedToolTask.cs index 19cd9c44912..75ed5ebc2fa 100644 --- a/src/Compilers/Core/MSBuildTask/ManagedToolTask.cs +++ b/src/Compilers/Core/MSBuildTask/ManagedToolTask.cs @@ -51,7 +51,7 @@ protected sealed override string GenerateCommandLineCommands() /// /// This generates the path to the executable that is directly ran. - /// This could be the managed assembly itself (on desktop .net on Windows), + /// This could be the managed assembly itself (on desktop .NET on Windows), /// or a runtime such as dotnet. /// protected sealed override string GenerateFullPathToTool() diff --git a/src/Compilers/Core/Portable/InternalUtilities/StringExtensions.cs b/src/Compilers/Core/Portable/InternalUtilities/StringExtensions.cs index 2cea9d40987..e6e4a6ac366 100644 --- a/src/Compilers/Core/Portable/InternalUtilities/StringExtensions.cs +++ b/src/Compilers/Core/Portable/InternalUtilities/StringExtensions.cs @@ -71,7 +71,7 @@ public static bool LooksLikeTypeParameterName(this string name) bool trimLeadingTypePrefix, Func convert) { - // Special case the common .net pattern of "IGoo" as a type name. In this case we + // Special case the common .NET pattern of "IGoo" as a type name. In this case we // want to generate "goo" as the parameter name. if (!string.IsNullOrEmpty(shortName)) { diff --git a/src/Compilers/VisualBasic/Portable/CodeGen/EmitArrayInitializer.vb b/src/Compilers/VisualBasic/Portable/CodeGen/EmitArrayInitializer.vb index 0392771e0e9..062a6e11779 100644 --- a/src/Compilers/VisualBasic/Portable/CodeGen/EmitArrayInitializer.vb +++ b/src/Compilers/VisualBasic/Portable/CodeGen/EmitArrayInitializer.vb @@ -238,7 +238,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGen InitializerCountRecursive(asArrayInit.Initializers, initCount, constInits) Else ' NOTE Default values Do Not need To be initialized. - ' .Net arrays are always zero-inited. + ' .NET arrays are always zero-inited. If Not init.IsDefaultValue() Then initCount += 1 If init.ConstantValueOpt IsNot Nothing Then diff --git a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb index 7124955dd7b..917d6dfc405 100644 --- a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb +++ b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb @@ -1278,7 +1278,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic ''' ''' In NetFx 4.0, block array initializers do not work on all combinations of {32/64 X Debug/Retail} when array elements are enums. ''' This is fixed in 4.5 thus enabling block array initialization for a very common case. - ''' We look for the presence of which was introduced in .Net 4.5 + ''' We look for the presence of which was introduced in .NET Framework 4.5 ''' Friend ReadOnly Property EnableEnumArrayBlockInitialization As Boolean Get diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb index 3bc6c20ceef..fae6b96db39 100644 --- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb +++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb @@ -1042,7 +1042,7 @@ End class token = metadata.GetTypeRef(metadata.GetAssemblyRef("mscorlib"), "System.Runtime.CompilerServices", "AssemblyAttributesGoHereM") Assert.True(token.IsNil) 'could the type ref be located? If not then the attribute's not there. - ' Exported types in .Net module cause PEVerify to fail. + ' Exported types in .NET module cause PEVerify to fail. CompileAndVerify(appCompilation, verify:=Verification.Fails, symbolValidator:=Sub(m) Dim metadataReader1 = DirectCast(m, PEModuleSymbol).Module.GetMetadataReader() @@ -1210,7 +1210,7 @@ End class Dim appCompilation = CreateCompilationWithMscorlib40AndReferences(app, {modRef, New VisualBasicCompilationReference(forwardedTypesCompilation)}, TestOptions.ReleaseDll) - ' Exported types in .Net module cause PEVerify to fail. + ' Exported types in .NET module cause PEVerify to fail. CompileAndVerify(appCompilation, verify:=Verification.Fails, symbolValidator:=Sub(m) Dim peReader1 = DirectCast(m, PEModuleSymbol).Module.GetMetadataReader() diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb index a58986c12b2..5461054d797 100644 --- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb +++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb @@ -3195,7 +3195,7 @@ BC37218: Type 'ns.CF2' forwarded to assembly 'ForwardedTypes1, Version=0.0.0.0, forwardedTypes1Ref }, TestOptions.ReleaseDll) - ' Exported types in .Net modules cause PEVerify to fail. + ' Exported types in .NET modules cause PEVerify to fail. CompileAndVerify(compilation, verify:=Verification.Fails).VerifyDiagnostics() compilation = CreateCompilationWithMscorlib40AndReferences(emptySource, diff --git a/src/Compilers/VisualBasic/Test/Syntax/Resources/VBAllInOne.vb b/src/Compilers/VisualBasic/Test/Syntax/Resources/VBAllInOne.vb index 5d6afed4f5a..9e7c6e23ddd 100644 --- a/src/Compilers/VisualBasic/Test/Syntax/Resources/VBAllInOne.vb +++ b/src/Compilers/VisualBasic/Test/Syntax/Resources/VBAllInOne.vb @@ -341,7 +341,7 @@ CaseLabel2: End Set End Property - 'vb.net can't support abstract member variable + 'VB.NET can't support abstract member variable Public ReadOnly Property P2() As String Get End Get diff --git a/src/Compilers/VisualBasic/Test/Syntax/Syntax/VBAllInOne.txt b/src/Compilers/VisualBasic/Test/Syntax/Syntax/VBAllInOne.txt index 4bd661b4e5b..7c26c62c68f 100644 --- a/src/Compilers/VisualBasic/Test/Syntax/Syntax/VBAllInOne.txt +++ b/src/Compilers/VisualBasic/Test/Syntax/Syntax/VBAllInOne.txt @@ -315,7 +315,7 @@ CaseLabel2: End Set End Property - 'vb.net can't support abstract member variable + 'VB.NET can't support abstract member variable Public ReadOnly Property P2() As String Get End Get diff --git a/src/Features/Core/Portable/ConvertAnonymousTypeToClass/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAnonymousTypeToClass/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs index a04c9fed61e..256b5720ea1 100644 --- a/src/Features/Core/Portable/ConvertAnonymousTypeToClass/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAnonymousTypeToClass/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs @@ -363,7 +363,7 @@ private static IPropertySymbol GenerateProperty(Document document, IPropertySymb // in the type. Instead, we just want to generate auto-props. So we effectively clone // the property, just throwing aways anything we don't need for that purpose. // - // We also want to follow general .net naming. So that means converting to pascal + // We also want to follow general .NET naming. So that means converting to pascal // case from camel-case. var getMethod = prop.GetMethod != null ? CreateAccessorSymbol(prop, MethodKind.PropertyGet) : null; diff --git a/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs b/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs index 9abc3b9c8f2..44a43766f96 100644 --- a/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs +++ b/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs @@ -373,7 +373,7 @@ private void ProvideEscapeCategoryCompletions(EmbeddedCompletionContext context) context.AddIfMissing($@"\k< {Regex_name_or_number} >", Regex_named_backreference_short, Regex_named_backreference_long, parentOpt, @"\k<".Length, insertionText: @"\k<>"); // Note: we intentionally do not add `\<>` to the list. While supported by the - // .net regex engine, it is effectively deprecated and discouraged from use. + // .NET regex engine, it is effectively deprecated and discouraged from use. // Instead, it is recommended that `\k<>` is used instead. // // context.AddIfMissing(@"\<>", "", "", parentOpt, @"\<".Length)); diff --git a/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.State.cs b/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.State.cs index 718ff0b0b06..584201792c0 100644 --- a/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.State.cs +++ b/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.State.cs @@ -110,7 +110,7 @@ private State(Compilation compilation) if (char.IsLower(name[0]) && !semanticDocument.SemanticModel.Compilation.IsCaseSensitive) { - // It's near universal in .Net that types start with a capital letter. As such, + // It's near universal in .NET that types start with a capital letter. As such, // if this name starts with a lowercase letter, don't even bother to offer // "generate type". The user most likely wants to run 'Add Import' (which will // then fix up a case where they typed an existing type name in lowercase, diff --git a/src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs b/src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs index 3416105df93..d0e5d81be35 100644 --- a/src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs +++ b/src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs @@ -121,7 +121,7 @@ internal abstract partial class AbstractNavigateToSearchService } // Would like to use CWT.AddOrUpdate. But that is not available on the - // version of .Net that we're using. So we need to take lock as we're + // version of .NET that we're using. So we need to take lock as we're // making multiple mutations. lock (s_lastProjectSearchCache) { diff --git a/src/Test/Utilities/Portable/TestResource.resx b/src/Test/Utilities/Portable/TestResource.resx index ab18adb61f0..a6736b4e1ee 100644 --- a/src/Test/Utilities/Portable/TestResource.resx +++ b/src/Test/Utilities/Portable/TestResource.resx @@ -1190,7 +1190,7 @@ CaseLabel2: End Set End Property - 'vb.net can't support abstract member variable + 'VB.NET can't support abstract member variable Public ReadOnly Property P2() As String Get End Get @@ -2234,7 +2234,7 @@ CaseLabel2: End Set End Property - 'vb.net can't support abstract member variable + 'VB.NET can't support abstract member variable Public ReadOnly Property P2() As String Get End Get diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs index 0b730f15564..c9ee699ab57 100644 --- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs +++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs @@ -383,7 +383,7 @@ internal bool IsCPSProject(CodeAnalysis.Project project) if (this.TryGetHierarchy(project.Id, out var hierarchy)) { - // Currently renaming files in CPS projects (i.e. .Net Core) doesn't work proprey. + // Currently renaming files in CPS projects (i.e. .NET Core) doesn't work proprey. // This is because the remove/add of the documents in CPS is not synchronous // (despite the DTE interfaces being synchronous). So Roslyn calls the methods // expecting the changes to happen immediately. Because they are deferred in CPS diff --git a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs index d941e7eda68..1a81a034134 100644 --- a/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs +++ b/src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs @@ -21,7 +21,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus internal sealed partial class ContainedDocument { // this is to support old venus/razor case before dev16. - // all new razor (asp.net core after dev16) should use thier own implementation not ours + // all new razor (asp.NET core after dev16) should use thier own implementation not ours public class DocumentServiceProvider : IDocumentServiceProvider { private readonly SpanMapper _spanMapper; diff --git a/src/Workspaces/CSharp/Portable/Extensions/SimpleNameSyntaxExtensions.cs b/src/Workspaces/CSharp/Portable/Extensions/SimpleNameSyntaxExtensions.cs index 467a5bc43e8..bab4a4462c0 100644 --- a/src/Workspaces/CSharp/Portable/Extensions/SimpleNameSyntaxExtensions.cs +++ b/src/Workspaces/CSharp/Portable/Extensions/SimpleNameSyntaxExtensions.cs @@ -69,7 +69,7 @@ public static bool LooksLikeStandaloneTypeName(this SimpleNameSyntax simpleName) // "Standalone type name". // // 1. Users are not going to name types the same name as C# keywords (contextual or otherwise). - // 2. Types in .Net are virtually always start with a Uppercase. While keywords are lowercase) + // 2. Types in .NET are virtually always start with a Uppercase. While keywords are lowercase) // // Having a lowercase identifier which matches a c# keyword is enough of a signal // to just not treat this as a standalone type name (even though for some identifiers diff --git a/src/Workspaces/CSharpTest/EmbeddedLanguages/RegularExpressions/CSharpRegexParserTests.cs b/src/Workspaces/CSharpTest/EmbeddedLanguages/RegularExpressions/CSharpRegexParserTests.cs index 2bfab165673..094613c7c9d 100644 --- a/src/Workspaces/CSharpTest/EmbeddedLanguages/RegularExpressions/CSharpRegexParserTests.cs +++ b/src/Workspaces/CSharpTest/EmbeddedLanguages/RegularExpressions/CSharpRegexParserTests.cs @@ -146,25 +146,25 @@ private SyntaxToken GetStringToken(string text) } catch (IndexOutOfRangeException) when (allowIndexOutOfRange) { - // bug with .net regex parser. Can happen with patterns like: (?<-0 + // bug with .NET regex parser. Can happen with patterns like: (?<-0 Assert.NotEmpty(tree.Diagnostics); return treeAndText; } catch (NullReferenceException) when (allowNullReference) { - // bug with .net regex parser. can happen with patterns like: (?(?S)) + // bug with .NET regex parser. can happen with patterns like: (?(?S)) return treeAndText; } catch (OutOfMemoryException) when (allowOutOfMemeory) { - // bug with .net regex parser. can happen with patterns like: a{2147483647,} + // bug with .NET regex parser. can happen with patterns like: a{2147483647,} return treeAndText; } catch (ArgumentException ex) { Assert.NotEmpty(tree.Diagnostics); - // Ensure the diagnostic we emit is the same as the .Net one. Note: we can only + // Ensure the diagnostic we emit is the same as the .NET one. Note: we can only // do this in en-US as that's the only culture where we control the text exactly // and can ensure it exactly matches Regex. We depend on localization to do a // good enough job here for other languages. diff --git a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/RegexSyntaxClassifier.cs b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/RegexSyntaxClassifier.cs index 988e039ad93..65ab1170d0e 100644 --- a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/RegexSyntaxClassifier.cs +++ b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/RegexSyntaxClassifier.cs @@ -316,7 +316,7 @@ public void Visit(RegexTextNode node) public void Visit(RegexPosixPropertyNode node) { - // The .net parser just interprets the [ of the node, and skips the rest. So + // The .NET parser just interprets the [ of the node, and skips the rest. So // classify the end part as a comment. Result.Add(new ClassifiedSpan(node.TextToken.VirtualChars[0].Span, ClassificationTypeNames.RegexText)); Result.Add(new ClassifiedSpan( diff --git a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs index e19bda64f9f..ffbba23ecc9 100644 --- a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs +++ b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs @@ -19,7 +19,7 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions /// /// Minimal copy of https://github.com/dotnet/corefx/blob/master/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCharClass.cs - /// Used to accurately determine if something is a WordChar according to the .Net regex engine. + /// Used to accurately determine if something is a WordChar according to the .NET regex engine. /// internal static class RegexCharClass { diff --git a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexLexer.cs b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexLexer.cs index a0ce11519bb..50912c06c66 100644 --- a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexLexer.cs +++ b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexLexer.cs @@ -440,7 +440,7 @@ public RegexToken ScanOctalCharacters(RegexOptions options) Position++; // Ecmascript doesn't allow octal values above 32 (0x20 in hex). Note: we do - // *not* add a diagnostic. This is not an error situation. The .net lexer + // *not* add a diagnostic. This is not an error situation. The .NET lexer // simply stops once it hits a value greater than a legal octal value. if (HasOption(options, RegexOptions.ECMAScript) && currentVal >= 0x20) { diff --git a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexNodes.cs b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexNodes.cs index 21c06ffbeeb..2b9e1e17a38 100644 --- a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexNodes.cs +++ b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexNodes.cs @@ -263,7 +263,7 @@ public override void Accept(IRegexNodeVisitor visitor) } /// - /// Represents a ```[:...:]``` node in a character class. Note: the .net regex parser + /// Represents a ```[:...:]``` node in a character class. Note: the .NET regex parser /// simply treats this as the character ```[``` and ignores the rest of the ```:...:]```. /// They latter part has no impact on the actual match engine that is produced. /// diff --git a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexParser.cs b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexParser.cs index 1259ca627c6..26de735c1df 100644 --- a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexParser.cs +++ b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexParser.cs @@ -23,18 +23,18 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions /// Produces a from a sequence of characters. /// /// Importantly, this parser attempts to replicate diagnostics with almost the exact same text - /// as the native .Net regex parser. This is important so that users get an understandable + /// as the native .NET regex parser. This is important so that users get an understandable /// experience where it appears to them that this is all one cohesive system and that the IDE /// will let them discover and fix the same issues they would encounter when previously trying /// to just compile and execute these regexes. /// /// - /// Invariants we try to maintain (and should consider a bug if we do not): l 1. If the .net + /// Invariants we try to maintain (and should consider a bug if we do not): l 1. If the .NET /// regex parser does not report an error for a given pattern, we should not either. it would be /// very bad if we told the user there was something wrong with there pattern when there really /// wasn't. /// - /// 2. If the .net regex parser does report an error for a given pattern, we should either not + /// 2. If the .NET regex parser does report an error for a given pattern, we should either not /// report an error (not recommended) or report the same error at an appropriate location in the /// pattern. Not reporting the error can be confusing as the user will think their pattern is /// ok, when it really is not. However, it can be acceptable to do this as it's not telling @@ -43,23 +43,23 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions /// documented in ). /// /// Note1: "report the same error" means that we will attempt to report the error using the same - /// text the .net regex parser uses for its error messages. This is so that the user is not + /// text the .NET regex parser uses for its error messages. This is so that the user is not /// confused when they use the IDE vs running the regex by getting different messages for the /// same issue. /// /// Note2: the above invariants make life difficult at times. This happens due to the fact that - /// the .net parser is multi-pass. Meaning it does a first scan (which may report errors), then + /// the .NET parser is multi-pass. Meaning it does a first scan (which may report errors), then /// does the full parse. This means that it might report an error in a later location during /// the initial scan than it would during the parse. We replicate that behavior to follow the /// second invariant. /// /// Note3: It would be nice if we could check these invariants at runtime, so we could control - /// our behavior by the behavior of the real .net regex engine. For example, if the .net regex + /// our behavior by the behavior of the real .NET regex engine. For example, if the .NET regex /// engine did not report any issues, we could suppress any diagnostics we generated and we /// could log an NFW to record which pattern we deviated on so we could fix the issue for a - /// future release. However, we cannot do this as the .net regex engine has no guarantees about + /// future release. However, we cannot do this as the .NET regex engine has no guarantees about /// its performance characteristics. For example, certain regex patterns might end up causing - /// that engine to consume unbounded amounts of CPU and memory. This is because the .net regex + /// that engine to consume unbounded amounts of CPU and memory. This is because the .NET regex /// engine is not just a parser, but something that builds an actual recognizer using techniques /// that are not necessarily bounded. As such, while we test ourselves around it during our /// tests, we cannot do the same at runtime as part of the IDE. @@ -67,7 +67,7 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions /// This parser was based off the corefx RegexParser based at: /// https://github.com/dotnet/corefx/blob/f759243d724f462da0bcef54e86588f8a55352c6/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs#L1 /// - /// Note4: The .Net parser itself changes over time (for example to fix behavior that even it + /// Note4: The .NET parser itself changes over time (for example to fix behavior that even it /// thinks is buggy). When this happens, we have to make a choice as to which behavior to /// follow. In general, the overall principle is that we should follow the more lenient /// behavior. If we end up taking the more strict interpretation we risk giving people an error @@ -104,7 +104,7 @@ internal partial struct RegexParser /// produce the next token after that. /// /// Whether or not trivia is allowed on the next token - /// produced. In the .net parser trivia is only allowed on a few constructs, + /// produced. In the .NET parser trivia is only allowed on a few constructs, /// and our parser mimics that behavior. Note that even if trivia is allowed, /// the type of trivia that can be scanned depends on the current RegexOptions. /// For example, if is currently @@ -135,7 +135,7 @@ public static RegexTree TryParse(VirtualCharSequence text, RegexOptions options) // to then parse the tree again, as the captures will affect how we interpret // certain things (i.e. escape references) and what errors will be reported. // - // This is necessary as .net regexes allow references to *future* captures. + // This is necessary as .NET regexes allow references to *future* captures. // As such, we don't know when we're seeing a reference if it's to something // that exists or not. var tree1 = new RegexParser(text, options, @@ -235,7 +235,7 @@ private RegexExpressionNode ParseAlternatingSequences(bool consumeCloseParen) /// /// Parses out code of the form: ...|...|... /// This is the type of code you have at the top level of a regex, or inside any grouping - /// contruct. Note that sequences can be empty in .net regex. i.e. the following is legal: + /// contruct. Note that sequences can be empty in .NET regex. i.e. the following is legal: /// /// ...||... /// @@ -853,7 +853,7 @@ private void MoveBackBeforePreviousScan() private RegexConditionalGroupingNode ParseConditionalExpressionGrouping( RegexToken openParenToken, RegexToken questionToken, RegexToken innerOpenParenToken) { - // Reproduce very specific errors the .net regex parser looks for. Technically, + // Reproduce very specific errors the .NET regex parser looks for. Technically, // we would error out in these cases no matter what. However, it means we can // stringently enforce that our parser produces the same errors as the native one. // @@ -1217,7 +1217,7 @@ private static RegexOptions OptionFromCode(VirtualChar ch) private RegexBaseCharacterClassNode ParseCharacterClass() { - // Note: ScanCharClass is one of the strangest function in the .net regex parser. Code + // Note: ScanCharClass is one of the strangest function in the .NET regex parser. Code // for it is here: // https://github.com/dotnet/corefx/blob/6ae0da1563e6e701bac61012c62ede8f8737f065/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs#L498 // @@ -1238,8 +1238,8 @@ private RegexBaseCharacterClassNode ParseCharacterClass() // ignoring that character on the right side of a character range. So, if you had // ```[#-\-b]```, then this *should* be treated as the character class containing // the range of character from '#' to '-', unioned with the character 'b'. However, - // .net will interpret this as the character class containing the range of characters - // from '#' to 'b'. We follow .Net here to keep our errors in sync with them. + // .NET will interpret this as the character class containing the range of characters + // from '#' to 'b'. We follow .NET here to keep our errors in sync with them. // // See the comment about this in ParseRightSideOfCharacterClassRange @@ -1506,7 +1506,7 @@ private bool HasProblem(RegexNodeOrToken component) private RegexExpressionNode ParseRightSideOfCharacterClassRange() { // Parsing the right hand side of a - is extremely strange (and most likely buggy) in - // the .net parser. Specifically, the .net parser will still consider itself on the + // the .NET parser. Specifically, the .NET parser will still consider itself on the // right side no matter how many escaped dashes it sees. So, for example, the following // is legal [a-\-] (even though \- is less than 'a'). Similarly, the following are // *illegal* [b-\-a] and [b-\-\-a]. That's because the range that is checked is @@ -1601,7 +1601,7 @@ private RegexPrimaryExpressionNode ParseSingleCharacterClassComponent(bool isFir ConsumeCurrentToken(allowTrivia: false)); } - // From the .net regex code: + // From the .NET regex code: // This is code for Posix style properties - [:Ll:] or [:IsTibetan:]. // It currently doesn't do anything other than skip the whole thing! if (!afterRangeMinus && _currentToken.Kind == RegexKind.OpenBracketToken && _lexer.IsAt(":")) @@ -1751,7 +1751,7 @@ private RegexEscapeNode ParsePossibleBackreferenceEscape(RegexToken backslashTok RegexToken backslashToken, bool allowTriviaAfterEnd) { // Small deviation: Ecmascript allows references only to captures that precede - // this position (unlike .net which allows references in any direction). However, + // this position (unlike .NET which allows references in any direction). However, // because we don't track position, we just consume the entire back-reference. // // This is addressable if we add position tracking when we locate all the captures. @@ -1849,7 +1849,7 @@ private RegexEscapeNode ParsePossibleKCaptureEscape(RegexToken backslashToken, b if (capture.IsMissing || closeToken.IsMissing) { // Native parser falls back to normal escape scanning, if it doesn't see a capture, - // or close brace. For normal .net regexes, this will then fail later (as \k is not + // or close brace. For normal .NET regexes, this will then fail later (as \k is not // a legal escape), but will succeed for ecmascript regexes. _lexer.Position = afterBackslashPosition; return ParseCharEscape(backslashToken, allowTriviaAfterEnd); @@ -1985,17 +1985,17 @@ private RegexControlEscapeNode ParseControlEscape(RegexToken backslashToken, boo { // From: https://github.com/dotnet/corefx/blob/80e220fc7009de0f0611ee6b52d4d5ffd25eb6c7/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs#L1450 - // Note: Roslyn accepts a control escape that current .Net parser does not. + // Note: Roslyn accepts a control escape that current .NET parser does not. // Specifically: \c[ // - // It is a bug that the .Net parser does not support this construct. The bug was + // It is a bug that the .NET parser does not support this construct. The bug was // reported at: https://github.com/dotnet/corefx/issues/26501 and was fixed for // CoreFx with https://github.com/dotnet/corefx/commit/80e220fc7009de0f0611ee6b52d4d5ffd25eb6c7 // // Because it was a bug, we follow the correct behavior. That means we will not // report a diagnostic for a Regex that someone might run on a previous version of - // .Net that ends up throwing at runtime. That's acceptable. Our goal is to match - // the latest .Net 'correct' behavior. Not intermediary points with bugs that have + // .NET that ends up throwing at runtime. That's acceptable. Our goal is to match + // the latest .NET 'correct' behavior. Not intermediary points with bugs that have // since been fixed. // \ca interpreted as \cA diff --git a/src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs b/src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs index 69548e1b239..4d49d962fe5 100644 --- a/src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs +++ b/src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs @@ -73,7 +73,7 @@ private static Option CreateOption(OptionGroup group, string name, T defau /// Default value of 120 was picked based on the amount of code in a github.com diff at 1080p. /// That resolution is the most common value as per the last DevDiv survey as well as the latest /// Steam hardware survey. This also seems to a reasonable length default in that shorter - /// lengths can often feel too cramped for .Net languages, which are often starting with a + /// lengths can often feel too cramped for .NET languages, which are often starting with a /// default indentation of at least 16 (for namespace, class, member, plus the final construct /// indentation). /// diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxTreeExtensions_SharedWithCodeStyle.cs b/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxTreeExtensions_SharedWithCodeStyle.cs index ae5a2783429..c7d7ed77a34 100644 --- a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxTreeExtensions_SharedWithCodeStyle.cs +++ b/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxTreeExtensions_SharedWithCodeStyle.cs @@ -18,7 +18,7 @@ public static bool OverlapsHiddenPosition(this SyntaxTree tree, TextSpan span, C return text.OverlapsHiddenPosition(span, (position, cancellationToken2) => { - // implements the ASP.Net IsHidden rule + // implements the ASP.NET IsHidden rule var lineVisibility = tree.GetLineVisibility(position, cancellationToken2); return lineVisibility == LineVisibility.Hidden || lineVisibility == LineVisibility.BeforeFirstLineDirective; }, diff --git a/src/Workspaces/Core/Portable/Shared/Utilities/BloomFilter.cs b/src/Workspaces/Core/Portable/Shared/Utilities/BloomFilter.cs index a34e002b43d..351ceac4aa0 100644 --- a/src/Workspaces/Core/Portable/Shared/Utilities/BloomFilter.cs +++ b/src/Workspaces/Core/Portable/Shared/Utilities/BloomFilter.cs @@ -99,7 +99,7 @@ private static int ComputeK(int expectedCount, double falsePositiveProbability) /// This is needed over the normal 'string.GetHashCode()' because we need to be able to generate /// 'k' different well distributed hashes for any given string s. Also, we want to be able to /// generate these hashes without allocating any memory. My ideal solution would be to use an - /// MD5 hash. However, there appears to be no way to do MD5 in .Net where you can: + /// MD5 hash. However, there appears to be no way to do MD5 in .NET where you can: /// /// a) feed it individual values instead of a byte[] /// diff --git a/src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs b/src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs index 61241fc1276..8a187875c65 100644 --- a/src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs +++ b/src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs @@ -89,7 +89,7 @@ public static T WaitAndGetResult_CanCallOnBackground(this Task task, Cance return task.Result; } - // NOTE(cyrusn): Once we switch over to .Net 4.5 we can make our SafeContinueWith overloads + // NOTE(cyrusn): Once we switch over to .NET Framework 4.5 we can make our SafeContinueWith overloads // simply call into task.ContinueWith(..., TaskContinuationOptions.LazyCancellation, ...) as // that will have the semantics that we want. From the TPL guys: // diff --git a/src/Workspaces/Core/Portable/Workspace/Host/Metadata/IFrameworkAssemblyPathResolver.cs b/src/Workspaces/Core/Portable/Workspace/Host/Metadata/IFrameworkAssemblyPathResolver.cs index bb0ff281802..ab039fe65d0 100644 --- a/src/Workspaces/Core/Portable/Workspace/Host/Metadata/IFrameworkAssemblyPathResolver.cs +++ b/src/Workspaces/Core/Portable/Workspace/Host/Metadata/IFrameworkAssemblyPathResolver.cs @@ -3,10 +3,10 @@ namespace Microsoft.CodeAnalysis.Host { /// - /// Provides a way to map from an assembly name to the actual path of the .Net framework + /// Provides a way to map from an assembly name to the actual path of the .NET Framework /// assemby with that name in the context of a specified project. For example, if the - /// assembly name is "System.Data" then a project targetting .Net 2.0 would resolve this - /// to a different path than a project targetting .Net 4.5. + /// assembly name is "System.Data" then a project targetting .NET 2.0 would resolve this + /// to a different path than a project targetting .NET 4.5. /// internal interface IFrameworkAssemblyPathResolver : IWorkspaceService { -- GitLab