diff --git a/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs b/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs index abe81619dd764cfe5d17c9b48e7aabab2c9d3b24..45a090ead2a48fa0838881066b35aac0f4664409 100644 --- a/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs +++ b/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs @@ -518,7 +518,7 @@ private bool CheckParameterValueKind(SyntaxNode node, BoundParameter parameter, // all parameters can be passed by ref/out or assigned to // except "in" parameters, which are readonly - if (parameterSymbol.RefKind == RefKind.RefReadOnly && RequiresAssignableVariable(valueKind)) + if (parameterSymbol.RefKind == RefKind.In && RequiresAssignableVariable(valueKind)) { ReportReadOnlyError(parameterSymbol, node, valueKind, checkingReceiver, diagnostics); return false; @@ -1291,9 +1291,9 @@ bool isRefEscape { var paramIndex = argsToParamsOpt.IsDefault ? argIndex : argsToParamsOpt[argIndex]; - if (parameters[paramIndex].RefKind == RefKind.RefReadOnly) + if (parameters[paramIndex].RefKind == RefKind.In) { - effectiveRefKind = RefKind.RefReadOnly; + effectiveRefKind = RefKind.In; refReadOnlyParametersMatchedWithArgs = refReadOnlyParametersMatchedWithArgs ?? ArrayBuilder.GetInstance(parameters.Length, fillWithValue: false); refReadOnlyParametersMatchedWithArgs[paramIndex] = true; } @@ -1321,7 +1321,7 @@ private static ParameterSymbol TryGetUnmatchedRefReadOnlyParameterAndFreeMatched break; } - if (parameter.RefKind == RefKind.RefReadOnly && + if (parameter.RefKind == RefKind.In && refReadOnlyParametersMatchedWithArgs?[i] != true && parameter.Type.IsByRefLikeType == false) { diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs index 453d4051777bef1f8e8ff426433a432e79042894..6842b969375cd30028058d1070f5bf4c45c6bb98 100644 --- a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs +++ b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs @@ -980,7 +980,7 @@ private static void CheckRestrictedTypeReceiver(BoundExpression expression, Comp CheckFeatureAvailability(receiverArgument.Syntax, MessageID.IDS_FeatureRefExtensionMethods, diagnostics); } - else if (receiverParameter.RefKind == RefKind.RefReadOnly) + else if (receiverParameter.RefKind == RefKind.In) { CheckFeatureAvailability(receiverArgument.Syntax, MessageID.IDS_FeatureRefExtensionMethods, diagnostics); } diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs index 210e62ea13aa3d625e5dddb9bd33bddd21c83806..d2047dc16245a126133956c441fa00af01e592ad 100644 --- a/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs +++ b/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs @@ -141,7 +141,7 @@ internal partial class Binder case SyntaxKind.ReadOnlyKeyword: Debug.Assert(refKind == RefKind.Ref || syntax.HasErrors); - refKind = RefKind.RefReadOnly; + refKind = RefKind.In; allValue = false; break; diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs index a0ba5e2462970dcb4d2c29c3d8b68569fc47304d..d4c00ba1feae47764708a5dc06e595e9c5dd8860 100644 --- a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs +++ b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs @@ -2575,7 +2575,7 @@ private RefKind GetEffectiveParameterRefKind(ParameterSymbol parameter, RefKind { var paramRefKind = parameter.RefKind; - if (paramRefKind == RefKind.RefReadOnly) + if (paramRefKind == RefKind.In) { // "in" parameters are effectively None for the purpose of overload resolution. paramRefKind = RefKind.None; diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs index 3005883e675a2821b2b1ad2258aa9e0ab185eb5b..ad08d7943b7bf6c1afadb850a35e7215f5183bfc 100644 --- a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs +++ b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs @@ -950,17 +950,17 @@ private static bool HadLambdaConversionError(DiagnosticBag diagnostics, Analyzed ParameterSymbol parameter = method.GetParameters()[parm]; bool isLastParameter = method.GetParameterCount() == parm + 1; // This is used to later decide if we need to try to unwrap a params array RefKind refArg = arguments.RefKind(arg); - RefKind refParm = parameter.RefKind; + RefKind refParameter = parameter.RefKind; if (arguments.IsExtensionMethodThisArgument(arg)) { Debug.Assert(refArg == RefKind.None); - if (refParm == RefKind.Ref || refParm == RefKind.RefReadOnly) + if (refParameter == RefKind.Ref || refParameter == RefKind.In) { // For ref and ref-readonly extension methods, we omit the "ref" modifier on receiver arguments. // Setting the correct RefKind for finding the correct diagnostics message. // For other ref kinds, keeping it as it is to find mismatch errors. - refArg = refParm; + refArg = refParameter; } } @@ -974,7 +974,7 @@ private static bool HadLambdaConversionError(DiagnosticBag diagnostics, Analyzed { // If the problem is that a lambda isn't convertible to the given type, also report why. // The argument and parameter type might match, but may not have same in/out modifiers - if (argument.Kind == BoundKind.UnboundLambda && refArg == refParm) + if (argument.Kind == BoundKind.UnboundLambda && refArg == refParameter) { ((UnboundLambda)argument).GenerateAnonymousFunctionConversionError(diagnostics, parameter.Type); } @@ -992,9 +992,9 @@ private static bool HadLambdaConversionError(DiagnosticBag diagnostics, Analyzed UnwrapIfParamsArray(parameter, isLastParameter)); } } - else if (refArg != refParm && !(refArg == RefKind.None && refParm == RefKind.RefReadOnly)) + else if (refArg != refParameter && !(refArg == RefKind.None && refParameter == RefKind.In)) { - if (refParm == RefKind.None || refParm == RefKind.RefReadOnly) + if (refParameter == RefKind.None || refParameter == RefKind.In) { // Argument {0} should not be passed with the {1} keyword diagnostics.Add( @@ -1012,7 +1012,7 @@ private static bool HadLambdaConversionError(DiagnosticBag diagnostics, Analyzed sourceLocation, symbols, arg + 1, - refParm.ToParameterDisplayString()); + refParameter.ToParameterDisplayString()); } } else diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitAddress.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitAddress.cs index d591bc14ae6b2d83534aa0d6ca4ce395c54d5385..65299f6fdc40c0a842a1f809b361be35af9cf57e 100644 --- a/src/Compilers/CSharp/Portable/CodeGen/EmitAddress.cs +++ b/src/Compilers/CSharp/Portable/CodeGen/EmitAddress.cs @@ -364,7 +364,7 @@ private bool HasHome(BoundExpression expression, bool needWriteable) case BoundKind.Parameter: return !needWriteable || - ((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.RefReadOnly; + ((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.In; case BoundKind.Local: // locals have home unless they are byval stack locals or ref-readonly diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs index c50e993006e65c843b74a1d6a2de180eeba99f72..f88fbce71c0b36fb23d181139166e23f2f097fa1 100644 --- a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs +++ b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs @@ -599,7 +599,7 @@ private void EmitArgument(BoundExpression argument, RefKind refKind) EmitExpression(argument, true); break; - case RefKind.RefReadOnly: + case RefKind.In: var temp = EmitAddress(argument, AddressKind.ReadOnly); AddExpressionTemp(temp); break; diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs index a056fa00167c7da8e7f63b8acc014fea03dd23e6..fc1c526ef6468d8f14c5df83efe87a7c157ae0e5 100644 --- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs +++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs @@ -378,7 +378,7 @@ private BoundStatement UpdateStatement(BoundSpillSequenceBuilder builder, BoundS case BoundKind.Call: var call = (BoundCall)expression; - if (refKind != RefKind.None && refKind != RefKind.RefReadOnly) + if (refKind != RefKind.None && refKind != RefKind.In) { Debug.Assert(call.Method.RefKind != RefKind.None); _F.Diagnostics.Add(ErrorCode.ERR_RefReturningCallAndAwait, _F.Syntax.Location, call.Method); @@ -794,7 +794,7 @@ public override BoundNode VisitCall(BoundCall node) receiver = node.ReceiverOpt; var refKind = node.Method.ContainingType.IsReadOnly? - RefKind.RefReadOnly: + RefKind.In: ReceiverSpillRefKind(receiver); receiver = Spill(receiverBuilder, VisitExpression(ref receiverBuilder, receiver), refKind: refKind); diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs index 41dc46552712d7251f335a595ff9c199e53fc293..b87d27c5ef29c16e7e6937545ee3908d9c0b6822 100644 --- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs +++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs @@ -597,7 +597,7 @@ private void CheckRefReadOnlySymbols(MethodSymbol symbol) { foreach (var parameter in symbol.Parameters) { - if (parameter.RefKind == RefKind.RefReadOnly) + if (parameter.RefKind == RefKind.In) { foundRefReadOnly = true; break; diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs index e1445b909e0d0dcf595ae22801df5dcab181fd7c..d3269841d0cf21bb65a67399cd1644ada1684a71 100644 --- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs +++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs @@ -503,7 +503,7 @@ private static ImmutableArray GetEffectiveArgumentRefKinds(ImmutableArr for (int i = 0; i < parameters.Length; i++) { var paramRefKind = parameters[i].RefKind; - if (paramRefKind == RefKind.RefReadOnly) + if (paramRefKind == RefKind.In) { if (refKindsBuilder == null) { @@ -661,9 +661,9 @@ private static ImmutableArray GetRefKindsOrNull(ArrayBuilder r BoundExpression argument = rewrittenArguments[a]; int p = (!argsToParamsOpt.IsDefault) ? argsToParamsOpt[a] : a; RefKind refKind = argumentRefKinds.RefKinds(a); - if (refKind == RefKind.None && parameters[p].RefKind == RefKind.RefReadOnly) + if (refKind == RefKind.None && parameters[p].RefKind == RefKind.In) { - refKind = RefKind.RefReadOnly; + refKind = RefKind.In; } Debug.Assert(arguments[p] == null); diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs index a2fac9fb9f9840464efc52c1671716becbefbfc6..896e5f0138342b466d541475901330b44c719d35 100644 --- a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs +++ b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs @@ -1269,7 +1269,7 @@ internal static BoundExpression NullOrDefault(TypeSymbol typeSymbol, SyntaxNode #endif ) { - if (refKind == RefKind.Out || refKind == RefKind.RefReadOnly) + if (refKind == RefKind.Out || refKind == RefKind.In) { refKind = RefKind.Ref; } diff --git a/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs b/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs index 7a2c9e807d15f960a4921cdb5ddaec8a19d06a4d..59672c5b7c049e4dfad9cc1b05045f6a4eebd9ef 100644 --- a/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs +++ b/src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs @@ -742,10 +742,8 @@ private void AddParameterRefKindIfRequired(RefKind refKind) AddKeyword(SyntaxKind.RefKeyword); AddSpace(); break; - case RefKind.RefReadOnly: - AddKeyword(SyntaxKind.RefKeyword); - AddSpace(); - AddKeyword(SyntaxKind.ReadOnlyKeyword); + case RefKind.In: + AddKeyword(SyntaxKind.InKeyword); AddSpace(); break; } diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs index 9f69385538bc8793a833398c1f4bc7e194a9714a..9219de45e7c63c48773721f122fc8e3bb796065e 100644 --- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs @@ -796,7 +796,7 @@ private bool IsValidExtensionMethodSignature() { case RefKind.None: case RefKind.Ref: - case RefKind.RefReadOnly: + case RefKind.In: return !parameter.IsParams; default: return false; diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs index e12e3b508f0c36a80b120e76e76eabb8704a027e..20d11f1ed8a637138554ad0a9daad61f55651124 100644 --- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs @@ -304,7 +304,7 @@ private sealed class PEParameterSymbolWithCustomModifiers : PEParameterSymbol _customModifiers = CSharpCustomModifier.Convert(customModifiers); _refCustomModifiers = CSharpCustomModifier.Convert(refCustomModifiers); - if (this.RefKind != RefKind.RefReadOnly && _refCustomModifiers.Any(modifier => !modifier.IsOptional && modifier.Modifier.IsWellKnownTypeInAttribute())) + if (this.RefKind != RefKind.In && _refCustomModifiers.Any(modifier => !modifier.IsOptional && modifier.Modifier.IsWellKnownTypeInAttribute())) { // The modreq is only accepted on RefReadOnly symbols isBad = true; diff --git a/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs index 8ae0fcf316c3696bf97b2455304eac44d31f588b..2b9def734b4a5e55507212a951af9a6ff7e39d79 100644 --- a/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs @@ -378,7 +378,7 @@ internal void DoGetExtensionMethods(ArrayBuilder methods, string n var thisParam = method.Parameters.First(); if ((thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) || - (thisParam.RefKind == RefKind.RefReadOnly && thisParam.Type.TypeKind != TypeKind.Struct)) + (thisParam.RefKind == RefKind.In && thisParam.Type.TypeKind != TypeKind.Struct)) { // For ref and ref-readonly extension methods, receivers need to be of the correct types to be considered in lookup continue; diff --git a/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs index 8706583116e0af35758ecc0ebb2da2abd85ad0be..27755ccd509af82befcb6b5363d4e81d143ecc6a 100644 --- a/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs @@ -145,7 +145,7 @@ public bool IsOptional RefKind refKind; return !IsParams && IsMetadataOptional && ((refKind = RefKind) == RefKind.None || - (refKind == RefKind.RefReadOnly) || + (refKind == RefKind.In) || (refKind == RefKind.Ref && ContainingSymbol.ContainingType.IsComImport)); } } diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs index 98e58c51d069522c847ce91fffd21ba9401ec572..b3c9fb1bcd08d1e594cee44fa28f9849be5b6359 100644 --- a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs +++ b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs @@ -125,7 +125,7 @@ internal static void EnsureIsReadOnlyAttributeExists(ImmutableArray { var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("M").GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Internal, parameter.GetAttributes(), module.ContainingAssembly.Name); }); @@ -108,7 +108,7 @@ class Test Assert.True(method.ReturnsByRefReadonly); var parameter = method.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), referenceA.Compilation.AssemblyName); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, method.GetReturnTypeAttributes(), referenceA.Compilation.AssemblyName); @@ -138,7 +138,7 @@ struct Test foreach (var parameter in method.Parameters) { - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), module.ContainingAssembly.Name); } }); @@ -190,7 +190,7 @@ struct Test Assert.Equal(2, method.ParameterCount); foreach (var parameter in method.Parameters) { - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), referenceA.Compilation.AssemblyName); } @@ -217,7 +217,7 @@ class Test { var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod(".ctor").Parameters.Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), module.ContainingAssembly.Name); }); } @@ -261,7 +261,7 @@ class Test { var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod(".ctor").Parameters.Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), referenceA.Compilation.AssemblyName); AssertNoIsReadOnlyAttributeExists(module.ContainingAssembly); @@ -391,7 +391,7 @@ class Test Assert.True(indexer.ReturnsByRefReadonly); var parameter = indexer.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), module.ContainingAssembly.Name); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, indexer.GetAttributes(), module.ContainingAssembly.Name); @@ -411,7 +411,7 @@ class Test CompileAndVerify(text, symbolValidator: module => { var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetProperty("this[]").GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Internal, parameter.GetAttributes(), module.ContainingAssembly.Name); }); @@ -463,7 +463,7 @@ class Test Assert.True(indexer.ReturnsByRefReadonly); var parameter = indexer.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), referenceA.Compilation.AssemblyName); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, indexer.GetAttributes(), referenceA.Compilation.AssemblyName); @@ -490,7 +490,7 @@ public class IsReadOnlyAttribute : System.Attribute { } Assert.True(method.ReturnsByRefReadonly); var parameter = method.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), module.ContainingAssembly.Name); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, method.GetReturnTypeAttributes(), module.ContainingAssembly.Name); @@ -507,7 +507,7 @@ public void RefReadOnlyIsWrittenToMetadata_NeedsToBeGenerated_Delegate_Parameter CompileAndVerify(text, symbolValidator: module => { var parameter = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Internal, parameter.GetAttributes(), module.ContainingAssembly.Name); }); @@ -552,7 +552,7 @@ public class IsReadOnlyAttribute : System.Attribute { } Assert.True(method.ReturnsByRefReadonly); var parameter = method.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), referenceA.Compilation.AssemblyName); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, method.GetReturnTypeAttributes(), referenceA.Compilation.AssemblyName); @@ -589,7 +589,7 @@ public void M() Assert.True(method.ReturnsByRefReadonly); var parameter = method.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), module.ContainingAssembly.Name); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, method.GetReturnTypeAttributes(), module.ContainingAssembly.Name); @@ -613,7 +613,7 @@ public void M() CompileAndVerify(text, options: options, symbolValidator: module => { var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("g__Inner|0_0").GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Internal, parameter.GetAttributes(), module.ContainingAssembly.Name); }); @@ -678,7 +678,7 @@ public void M() Assert.True(method.ReturnsByRefReadonly); var parameter = method.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), referenceA.Compilation.AssemblyName); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, method.GetReturnTypeAttributes(), referenceA.Compilation.AssemblyName); @@ -717,7 +717,7 @@ public void M1() Assert.True(method.ReturnsByRefReadonly); var parameter = method.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), module.ContainingAssembly.Name); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, method.GetReturnTypeAttributes(), module.ContainingAssembly.Name); @@ -745,7 +745,7 @@ public void M1() CompileAndVerify(text, options: options, symbolValidator: module => { var parameter = module.GlobalNamespace.GetMember("Test.<>c.b__0_0").GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Internal, parameter.GetAttributes(), module.ContainingAssembly.Name); }); @@ -813,7 +813,7 @@ public void M1() Assert.True(method.ReturnsByRefReadonly); var parameter = method.GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), referenceA.Compilation.AssemblyName); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, method.GetReturnTypeAttributes(), referenceA.Compilation.AssemblyName); @@ -1151,7 +1151,7 @@ public class Test AssertNoIsReadOnlyAttributeExists(module.ContainingAssembly); var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("M").GetParameters().Single(); - Assert.Equal(RefKind.RefReadOnly, parameter.RefKind); + Assert.Equal(RefKind.In, parameter.RefKind); AssertReferencedIsReadOnlyAttribute(Accessibility.Public, parameter.GetAttributes(), reference.Display); }); } diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadonlyStructTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadonlyStructTests.cs index e98a12aeccc625783e347d373cdf58584f3f1fc2..9c967e2dcbc751529deb4a206e2cca53da87db75 100644 --- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadonlyStructTests.cs +++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadonlyStructTests.cs @@ -814,29 +814,29 @@ public override string ToString() NamedTypeSymbol namedType = comp.GetTypeByMetadataName("Program+S1"); Assert.True(namedType.IsReadOnly); Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("M1").ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("ToString").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); // S1 namedType = comp.GetTypeByMetadataName("Program+S1`1"); Assert.True(namedType.IsReadOnly); Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("M1").ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("ToString").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); // T TypeSymbol type = namedType.TypeParameters[0]; Assert.True(namedType.IsReadOnly); Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("M1").ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("ToString").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); // S1 namedType = namedType.Construct(comp.ObjectType); Assert.True(namedType.IsReadOnly); Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("M1").ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("ToString").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); // S2 namedType = comp.GetTypeByMetadataName("Program+S2"); @@ -970,29 +970,29 @@ public override string ToString() NamedTypeSymbol namedType = comp.GetTypeByMetadataName("Program+S1"); Assert.True(namedType.IsReadOnly); Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("M1").ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("ToString").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); // S1 namedType = comp.GetTypeByMetadataName("Program+S1`1"); Assert.True(namedType.IsReadOnly); Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("M1").ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("ToString").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); // T TypeSymbol type = namedType.TypeParameters[0]; Assert.True(namedType.IsReadOnly); Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("M1").ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("ToString").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); // S1 namedType = namedType.Construct(comp.ObjectType); Assert.True(namedType.IsReadOnly); Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("M1").ThisParameter.RefKind); - Assert.Equal(RefKind.RefReadOnly, namedType.GetMethod("ToString").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); + Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); // S2 namedType = comp.GetTypeByMetadataName("Program+S2"); diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RefExtensionMethodsTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RefExtensionMethodsTests.cs index 45bbd2226711b298f7da00685ac9f83abaf6a20d..c02278f0faef66c1e5287b236390389b5836d151 100644 --- a/src/Compilers/CSharp/Test/Semantic/Semantics/RefExtensionMethodsTests.cs +++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RefExtensionMethodsTests.cs @@ -1962,7 +1962,7 @@ public static class Ext var model = comp.GetSemanticModel(tree); var symbol = (ParameterSymbol)model.GetDeclaredSymbolForNode(parameter.AsNode()); - Assert.Equal(RefKind.RefReadOnly, symbol.RefKind); + Assert.Equal(RefKind.In, symbol.RefKind); } [Fact] diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs index 24b3efb59ad538450e11029f43f5d656bac3d1e4..7650294d374dfe8425913e5cda8b9b5a9e11f28e 100644 --- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs +++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs @@ -750,7 +750,7 @@ public void RefReadonlyReturningDelegate() Assert.Equal(RefKind.RefReadOnly, d.DelegateInvokeMethod.RefKind); Assert.Equal(RefKind.RefReadOnly, ((MethodSymbol)d.GetMembers("EndInvoke").Single()).RefKind); - Assert.Equal(RefKind.RefReadOnly, d.DelegateInvokeMethod.Parameters[0].RefKind); + Assert.Equal(RefKind.In, d.DelegateInvokeMethod.Parameters[0].RefKind); } [Fact] @@ -779,14 +779,14 @@ public static void Main() Assert.False(lambda.ReturnsByRef); Assert.True(lambda.ReturnsByRefReadonly); - Assert.Equal(lambda.Parameters[0].RefKind, RefKind.RefReadOnly); + Assert.Equal(lambda.Parameters[0].RefKind, RefKind.In); lambdaSyntax = tree.GetCompilationUnitRoot().DescendantNodes().OfType().Single(); lambda = (LambdaSymbol)model.GetSymbolInfo(lambdaSyntax).Symbol; Assert.False(lambda.ReturnsByRef); Assert.True(lambda.ReturnsByRefReadonly); - Assert.Equal(lambda.Parameters[0].RefKind, RefKind.RefReadOnly); + Assert.Equal(lambda.Parameters[0].RefKind, RefKind.In); } } } diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/ExpressionBodiedPropertyTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/ExpressionBodiedPropertyTests.cs index 54d5e344f1918e219d0ca8d9f325155e2f0f82d2..c296a04c1f9ea2cb99be4e5737d99aa4ebd787e1 100644 --- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/ExpressionBodiedPropertyTests.cs +++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/ExpressionBodiedPropertyTests.cs @@ -554,7 +554,7 @@ class C Assert.False(p.GetMethod.IsImplicitlyDeclared); Assert.True(p.IsExpressionBodied); Assert.Equal(RefKind.RefReadOnly, p.GetMethod.RefKind); - Assert.Equal(RefKind.RefReadOnly, p.GetMethod.Parameters[0].RefKind); + Assert.Equal(RefKind.In, p.GetMethod.Parameters[0].RefKind); Assert.False(p.ReturnsByRef); Assert.False(p.GetMethod.ReturnsByRef); Assert.True(p.ReturnsByRefReadonly); @@ -582,7 +582,7 @@ class C Assert.False(p.GetMethod.IsImplicitlyDeclared); Assert.True(p.IsExpressionBodied); Assert.Equal(RefKind.RefReadOnly, p.GetMethod.RefKind); - Assert.Equal(RefKind.RefReadOnly, p.GetMethod.Parameters[0].RefKind); + Assert.Equal(RefKind.In, p.GetMethod.Parameters[0].RefKind); Assert.False(p.ReturnsByRef); Assert.False(p.GetMethod.ReturnsByRef); Assert.True(p.ReturnsByRefReadonly); diff --git a/src/VisualStudio/Core/Test/ChangeSignature/ChangeSignatureViewModelTests.vb b/src/VisualStudio/Core/Test/ChangeSignature/ChangeSignatureViewModelTests.vb index 47ba9ac148c1ebfa09b405f811ebc6e34d01190f..d5ccd7b6f65646ae70d8706bb34cbb0f91cc8fe6 100644 --- a/src/VisualStudio/Core/Test/ChangeSignature/ChangeSignatureViewModelTests.vb +++ b/src/VisualStudio/Core/Test/ChangeSignature/ChangeSignatureViewModelTests.vb @@ -359,7 +359,7 @@ class MyClass Public Async Function TestRefKindsDisplayedCorrectly() As Tasks.Task - Dim includedInTest = {RefKind.None, RefKind.Ref, RefKind.Out, RefKind.RefReadOnly} + Dim includedInTest = {RefKind.None, RefKind.Ref, RefKind.Out, RefKind.In, RefKind.RefReadOnly} Assert.Equal(includedInTest, EnumUtilities.GetValues(Of RefKind)()) Dim markup =