ReturnType

Binder\Binder.ValueChecks.cs (3)

54Method is { RefKind: not RefKind.None, ReturnType: { } returnType } && 2607return method.ReturnType.IsRefLikeOrAllowsRefLikeType(); 4660Debug.Assert(constructMethod.ReturnType.Equals(expr.Type, TypeCompareKind.AllIgnoreOptions));

Binder\Binder_Await.cs (2)

40TypeSymbol awaitExpressionType = info.GetResult?.ReturnType ?? (hasErrors ? CreateErrorType() : Compilation.DynamicType); 186new CSDiagnosticInfo(ErrorCode.ERR_BadAwaitWithoutAsyncMethod, method.ReturnType);

Binder\Binder_Conversions.cs (11)

591readonlySpanType.Equals(method.ReturnType.OriginalDefinition, TypeCompareKind.ConsiderEverything)); 642arg.destination.Equals(method.ReturnType.OriginalDefinition, TypeCompareKind.ConsiderEverything) && 648((NamedTypeSymbol)method.ReturnType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(((NamedTypeSymbol)arg.destination).TypeParameters[0], TypeCompareKind.ConsiderEverything)); 671method.ReturnType.Equals(readOnlySpanType, TypeCompareKind.ConsiderEverything)) 864collectionBuilderInvocationPlaceholder = new BoundValuePlaceholder(syntax, collectionBuilderMethod.ReturnType) { WasCompilerGenerated = true }; 1918conversion = Conversions.ClassifyImplicitConversionFromType(methodWithTargetTypeParameters.ReturnType, targetType.OriginalDefinition, ref candidateUseSiteInfo); 2102TypeSymbol conversionReturnType = conversion.BestUserDefinedConversionAnalysis.Operator.ReturnType; 2898var methodReturnType = method.ReturnType; 2899var delegateReturnType = delegateOrFuncPtrMethod.ReturnType; 2916Error(diagnostics, ErrorCode.ERR_BadRetType, errorLocation, method, method.ReturnType); 3047if ((selectedMethod.HasParameterContainingPointerType() || selectedMethod.ReturnType.ContainsPointerOrFunctionPointer())

Binder\Binder_Crefs.cs (2)

462symbol.Kind != SymbolKind.Method || TypeSymbol.Equals(((MethodSymbol)symbol).ReturnType, returnType, TypeCompareKind.ConsiderEverything2), returnType); 721if (ContainsNestedTypeOfUnconstructedGenericType(signature.ReturnType))

Binder\Binder_Deconstruct.cs (1)

694if (deconstructMethod.ReturnType.GetSpecialTypeSafe() != SpecialType.System_Void)

Binder\Binder_Expressions.cs (2)

4838TypeSymbol constructorReturnType = constructor.ReturnType; 10587getMethod.ReturnType.SpecialType == SpecialType.System_Int32 &&

Binder\Binder_InterpolatedString.cs (1)

983if (call is BoundCall { Method: { ReturnType: var returnType } method })

Binder\Binder_Invocation.cs (3)

1202var returnType = methodResult.Member.ReturnType; 2488funcPtr.Signature.ReturnType, 2507funcPtr.Signature.ReturnType,

Binder\Binder_Operators.cs (2)

719type = method.ReturnType; 1687SourceUserDefinedOperatorSymbol.IsSelfConstrainedTypeParameter((definition = signature.Method.OriginalDefinition).ReturnType.StrippedType(), definition.ContainingType));

Binder\Binder_Statements.cs (6)

1299elementType = fixedPatternMethod.ReturnType; 2987TypeSymbol returnType = symbol.ReturnType; 3403lambda.MessageID.Localize(), lambda.ReturnType); 3539var inferringLambda = this.ContainingMemberOrLambda is MethodSymbol method && (object)method.ReturnType == LambdaSymbol.ReturnTypeIsBeingInferred; 3985type: baseConstructor.ReturnType, 4029type: baseConstructor.ReturnType,

Binder\ExecutableCodeBinder.cs (1)

140var returnType = iterator.ReturnType;

Binder\ForEachLoopBinder.cs (13)

263var placeholder = new BoundAwaitableValuePlaceholder(expr, builder.MoveNextInfo?.Method.ReturnType ?? CreateErrorType()); 266if (!hasErrors && awaitInfo.GetResult?.ReturnType.SpecialType != SpecialType.System_Boolean) 538Conversion currentConversionClassification = this.Conversions.ClassifyConversionFromType(builder.CurrentPropertyGetter.ReturnType, builder.ElementType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 540TypeSymbol getEnumeratorType = getEnumeratorMethod.ReturnType; 570builder.CurrentPlaceholder = new BoundValuePlaceholder(_syntax, builder.CurrentPropertyGetter.ReturnType).MakeCompilerGenerated(); 612: builder.PatternDisposeInfo.Method.ReturnType; 1066diagnostics.Add(isAsync ? ErrorCode.ERR_BadGetAsyncEnumerator : ErrorCode.ERR_BadGetEnumerator, collectionSyntax.Location, getEnumeratorMethod.ReturnType, getEnumeratorMethod); 1136TypeSymbol enumeratorType = specificGetEnumeratorMethod.ReturnType; 1195builder.GetEnumeratorInfo.Method.ReturnType.SpecialType == SpecialType.System_Collections_IEnumerator); 1221TypeSymbol enumeratorType = builder.GetEnumeratorInfo.Method.ReturnType; 1334TypeSymbol.Equals(builder.GetEnumeratorInfo.Method.ReturnType, this.Compilation.GetSpecialType(SpecialType.System_Collections_IEnumerator), TypeCompareKind.ConsiderEverything2)); 1648TypeSymbol enumeratorType = getEnumeratorMethod.ReturnType; 1758return moveNextMethodCandidate.OriginalDefinition.ReturnType.SpecialType != SpecialType.System_Boolean;

Binder\InMethodBinder.cs (1)

129TypeSymbol returnType = _methodSymbol.ReturnType;

Binder\LockBinder.cs (1)

86var scopeType = enterScopeMethod.ReturnType;

Binder\Semantics\AccessCheck.cs (1)

168if (!IsSymbolAccessibleCore(funcPtr.Signature.ReturnType, within, throughTypeOpt: null, out failedThroughTypeCheck, compilation, ref useSiteInfo, basesBeingResolved))

Binder\Semantics\Conversions\Conversions.cs (2)

261returnRefKind: delegateInvokeMethodOpt.RefKind, returnType: delegateInvokeMethodOpt.ReturnType, 413returnType: delegateInvokeMethod.ReturnType);

Binder\Semantics\Conversions\ConversionsBase.cs (1)

1488!invokeMethod.ReturnType.Equals(returnType.Type, TypeCompareKind.AllIgnoreOptions))

Binder\Semantics\Conversions\UserDefinedExplicitConversions.cs (2)

266if (op.ReturnsVoid || op.ParameterCount != 1 || op.ReturnType.TypeKind == TypeKind.Error) 272TypeSymbol convertsTo = op.ReturnType;

Binder\Semantics\Conversions\UserDefinedImplicitConversions.cs (2)

301TypeSymbol convertsTo = op.ReturnType; 420if (!TypeSymbol.Equals(conv.ToType, conv.Operator.ReturnType, TypeCompareKind.ConsiderEverything2))

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (3)

1004TypeSymbol resultType = op.ReturnType; 1019TypeSymbol resultType = op.ReturnType; 1548TypeSymbol resultType = method.ReturnType;

Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (3)

196TypeSymbol resultType = method.ReturnType; 799TypeSymbol resultType = op.ReturnType; 828TypeSymbol resultType = op.ReturnType;

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (5)

1095var returnType = method.ReturnType; 2459if ((sourceSignature.ReturnType.IsReferenceType || sourceSignature.ReturnType.IsFunctionPointer()) && sourceSignature.RefKind == RefKind.None) 2809if ((sourceSignature.ReturnType.IsReferenceType || sourceSignature.ReturnType.IsFunctionPointer()) && sourceSignature.RefKind == RefKind.None)

Binder\Semantics\OverloadResolution\OverloadResolution.cs (9)

871if (returnType is null || method.ReturnType.Equals(returnType, TypeCompareKind.AllIgnoreOptions)) 877returnsMatch = Conversions.HasIdentityOrImplicitReferenceConversion(method.ReturnType, returnType, ref useSiteInfo); 880returnsMatch = ConversionsBase.HasImplicitPointerToVoidConversion(method.ReturnType, returnType) 881|| Conversions.HasImplicitPointerConversion(method.ReturnType, returnType, ref useSiteInfo); 3277!(y = invoke.ReturnType).IsVoidType()) 3563TypeSymbol r1 = invoke1.ReturnType; 3564TypeSymbol r2 = invoke2.ReturnType; 3696TypeSymbol r1 = invoke1.ReturnType; 3697TypeSymbol r2 = invoke2.ReturnType;

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (1)

711diagnostics.Add(ErrorCode.ERR_BadRetType, location, method, method.ReturnType);

Binder\UsingStatementBinder.cs (1)

228awaitableType = disposeMethod.ReturnType;

Binder\WithLambdaParametersBinder.cs (1)

50return lambdaSymbol.ReturnType;

BoundTree\Constructors.cs (2)

154type: method.ReturnType, 225type: method.ReturnType,

BoundTree\UnboundLambda.cs (3)

304var delegateReturnType = delegateType?.GetDelegateType()?.DelegateInvokeMethod?.ReturnType as NamedTypeSymbol; 823(object)LambdaSymbol.InferenceFailureReturnType != lambdaSymbol.ReturnType && 1142var delegateReturnType = invoke.ReturnType as NamedTypeSymbol;

CodeGen\CodeGenerator.cs (1)

193result = AllocateTemp(_method.ReturnType, _boundBody.Syntax, slotConstraints);

CodeGen\EmitExpression.cs (3)

3692if (!TypeSymbol.Equals(node.Type, getMethod.ReturnType, TypeCompareKind.ConsiderEverything2)) 3719if (!TypeSymbol.Equals(node.Type, getField.ReturnType, TypeCompareKind.ConsiderEverything2)) 4089EmitLoadIndirect(method.ReturnType, syntax);

Compilation\CSharpCompilation.cs (4)

2196if (method.ReturnType.IsVoidType() || method.ReturnType.SpecialType == SpecialType.System_Int32) 2201if (!(method.ReturnType is NamedTypeSymbol namedType)) 2238TypeSymbol returnType = method.ReturnType;

Compiler\ClsComplianceChecker.cs (1)

734type = method.ReturnType;

Compiler\MethodCompiler.cs (1)

245var returnType = entryPoint.ReturnType;

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

119s_parameterOrReturnTypeInstance.Visit(symbol.ReturnType, builder);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (4)

397var otherReturnType = (TypeSymbol?)Visit(sig.ReturnType); 608return _comparer.Equals(method.ReturnType, other.ReturnType) && 919var translatedReturnType = (TypeSymbol)Visit(sig.ReturnType);

Emitter\Model\MethodReference.cs (1)

111return ((PEModuleBuilder)context.Module).Translate(UnderlyingMethod.ReturnType, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);

Emitter\Model\MethodSymbolAdapter.cs (1)

242return ((PEModuleBuilder)context.Module).Translate(AdaptedMethodSymbol.ReturnType,

FlowAnalysis\NullableWalker.cs (7)

3773invokeMethod.ReturnType.Equals(l.ReturnType, TypeCompareKind.AllNullableIgnoreOptions | TypeCompareKind.IgnoreTupleNames); 6729|| method.ReturnType.SpecialType != SpecialType.System_Boolean 7614if (method.ReturnType.SpecialType == SpecialType.System_Boolean 11722var moveNextAsyncMethod = (MethodSymbol)AsMemberOfType(reinferredGetEnumeratorMethod.ReturnType, enumeratorInfoOpt.MoveNextInfo.Method); 11738var disposeAsyncMethod = (MethodSymbol)AsMemberOfType(reinferredGetEnumeratorMethod.ReturnType, originalDisposeMethod); 12792method.ReturnType, errorLocation: null, diagnostics: null);

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (3)

184var returnType = (NamedTypeSymbol)method.ReturnType; 255var returnType = (NamedTypeSymbol)method.ReturnType; 489method.ReturnType.Equals(builderType, TypeCompareKind.AllIgnoreOptions))

Lowering\AsyncRewriter\AsyncRewriter.AsyncIteratorRewriter.cs (3)

313var moveNextAsyncReturnType = (NamedTypeSymbol)IAsyncEnumerableOfElementType_MoveNextAsync.ReturnType; 432TypeSymbol returnType = IAsyncDisposable_DisposeAsync.ReturnType; 454.AsMember((NamedTypeSymbol)IAsyncDisposable_DisposeAsync.ReturnType);

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (4)

573_bound.Literal(isLifted && !TypeSymbol.Equals(methodOpt.ReturnType, type, TypeCompareKind.ConsiderEverything2)), 706var resultType = (isLifted && method.ReturnType.IsNonNullableValueType() && node.Type.IsNullableType()) ? 707_nullableType.Construct(method.ReturnType) : method.ReturnType;

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

127if (ReturnType.ContainsNativeIntegerWrapperType())

Lowering\IteratorRewriter\IteratorRewriter.cs (2)

68switch (method.ReturnType.OriginalDefinition.SpecialType) 81throw ExceptionUtilities.UnexpectedValue(method.ReturnType.OriginalDefinition.SpecialType);

Lowering\LocalRewriter\LocalRewriter.cs (1)

675Debug.Assert(TypeSymbol.Equals(type, getTypeFromHandle.ReturnType, TypeCompareKind.AllIgnoreOptions));

Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (1)

248TypeSymbol type = e.Property.GetMethod.ReturnType;

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (1)

369setMethod.ReturnType);

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (3)

803Debug.Assert(TypeSymbol.Equals(method.ReturnType, type, TypeCompareKind.ConsiderEverything2)); 2048? new BoundBinaryOperator(syntax, operatorKind, null, method, constrainedToTypeOpt: null, default(LookupResultKind), loweredLeft, loweredRight, method.ReturnType) 2050BoundExpression result = method.ReturnType.SpecialType == SpecialType.System_Delegate ?

Lowering\LocalRewriter\LocalRewriter_Call.cs (4)

486method.ReturnType); 504type: method.ReturnType); 521method.ReturnType); 1480type: arrayEmpty.ReturnType);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (3)

200if (getEnumeratorMethod?.ReturnType.IsValueType == true) 226(!builder.ReturnType.IsRefLikeType || builder.Parameters[0].EffectiveScope == ScopedKind.ScopedValue)) 506type: constructMethod.ReturnType);

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (7)

661if (Binder.TryFindCastUpMethod(implicitOperator.ReturnType.OriginalDefinition, destinationType.OriginalDefinition) is not { } castUpMethodDefinition) 895TypeSymbol userDefinedConversionRewrittenType = conversion.Method.ReturnType; 1383if (call.Method.ReturnType.IsValidNullableTypeArgument()) 1385Debug.Assert(resultType.IsNullableType() && TypeSymbol.Equals(resultType.GetNullableUnderlyingType(), call.Method.ReturnType, TypeCompareKind.ConsiderEverything2)); 1746Debug.Assert(TypeSymbol.Equals(method.ReturnType, toType, TypeCompareKind.ConsiderEverything2)); 1770Conversion toConversion = TryMakeConversion(syntax, conversion.UserDefinedToConversion, meth.ReturnType, toType, @checked: @checked); 1876Conversion toConversion = TryMakeConversion(syntax, meth.ReturnType, toType, @checked: @checked);

Lowering\LocalRewriter\LocalRewriter_Event.cs (1)

58Debug.Assert(method.ReturnType.Equals(node.Type, TypeCompareKind.AllIgnoreOptions));

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (1)

321getPinnableMethod.ReturnType,

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (3)

155TypeSymbol enumeratorType = getEnumeratorInfo.Method.ReturnType; 234rewrittenCondition = RewriteAwaitExpression(forEachSyntax, rewrittenCondition, awaitableInfo, awaitableInfo.GetResult.ReturnType, debugInfo, used: true); 477TypeSymbol awaitExpressionType = disposeAwaitableInfoOpt.GetResult?.ReturnType ?? _compilation.DynamicType;

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (2)

244getItemOrSliceHelper = getItemOrSliceHelper.AsMember((NamedTypeSymbol)createSpan.ReturnType); 393getItemOrSliceHelper = getItemOrSliceHelper.AsMember((NamedTypeSymbol)createSpan.ReturnType);

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (1)

572BoundExpression binary = MakeBinaryOperator(_factory.Syntax, single.Kind, left, right, single.MethodSymbolOpt?.ReturnType ?? boolType, single.MethodSymbolOpt, single.ConstrainedToTypeOpt);

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (2)

114Debug.Assert(TypeSymbol.Equals(type, method.ReturnType, TypeCompareKind.ConsiderEverything2)); 791Debug.Assert(TypeSymbol.Equals(node.MethodOpt.GetParameterType(0), node.MethodOpt.ReturnType, TypeCompareKind.ConsiderEverything2));

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (1)

480TypeSymbol awaitExpressionType = awaitOpt.GetResult?.ReturnType ?? _compilation.DynamicType;

Lowering\SyntheticBoundNodeFactory.cs (7)

569var conversion = Compilation.Conversions.ClassifyConversionFromType(expression.Type, CurrentFunction.ReturnType, isChecked: false, ref useSiteInfo); 575expression = BoundConversion.Synthesized(Syntax, expression, conversion, false, explicitCastInCode: false, conversionGroupOpt: null, ConstantValue.NotAvailable, CurrentFunction.ReturnType); 868type: method.ReturnType, hasErrors: method.OriginalDefinition is ErrorMethodSymbol) 908argsToParamsOpt: ImmutableArray<int>.Empty, defaultArguments: default(BitVector), resultKind: LookupResultKind.Viable, type: method.ReturnType) 1282Debug.Assert(TypeSymbol.Equals(systemType, getTypeFromHandle.ReturnType, TypeCompareKind.AllIgnoreOptions)); 1326Debug.Assert(result.Type.IsErrorType() || result.Type!.IsDerivedFrom(result.GetMethodFromHandle!.ReturnType, TypeCompareKind.AllIgnoreOptions, ref discardedUseSiteInfo)); 1433Debug.Assert(result.Type.IsErrorType() || result.Type!.IsDerivedFrom(result.GetMethodFromHandle!.ReturnType, TypeCompareKind.AllIgnoreOptions, ref discardedUseSiteInfo));

Operations\CSharpOperationFactory.cs (1)

1911HasImplicitConversionToOrImplementsVarianceCompatibleInterface(enumeratorInfoOpt.GetEnumeratorInfo.Method.ReturnType,

Symbols\Compilation_WellKnownMembers.cs (1)

1155return method.ReturnType;

Symbols\ConversionSignatureComparer.cs (3)

51return member1.ReturnType.Equals(member2.ReturnType, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes) 64hash = Hash.Combine(member.ReturnType.GetHashCode(), hash);

Symbols\ErrorMethodSymbol.cs (1)

172get { return this.ReturnType.IsVoidType(); }

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (2)

761=> Hash.Combine(ReturnType, Hash.Combine(((int)CallingConvention).GetHashCode(), ((int)FunctionPointerTypeSymbol.GetRefKindForHashCode(RefKind)).GetHashCode())); 802return ReturnType.GetUnificationUseSiteDiagnosticRecursive(ref result, owner, ref checkedTypes)

Symbols\MemberSymbolExtensions.cs (1)

850return method.ReturnType.ContainsTupleNames() || method.Parameters.Any(static p => p.Type.ContainsTupleNames());

Symbols\Metadata\PE\PEEventSymbol.cs (1)

202TypeSymbol.Equals(_addMethod.ReturnType, token, TypeCompareKind.ConsiderEverything2) &&

Symbols\Metadata\PE\PEMethodSymbol.cs (1)

632public override bool ReturnsVoid => this.ReturnType.IsVoidType();

Symbols\MethodSymbol.cs (2)

457(requireSameReturnType && !this.ReturnType.Equals(overridden.ReturnType, TypeCompareKind.AllIgnoreOptions)))

Symbols\MethodSymbolExtensions.cs (6)

162&& method.ReturnType is NamedTypeSymbol { Arity: 0 } 163&& (method.HasAsyncMethodBuilderAttribute(builderArgument: out _) || method.ReturnType.IsNonGenericTaskType(compilation)); 172&& method.ReturnType is NamedTypeSymbol { Arity: 1 } 173&& (method.HasAsyncMethodBuilderAttribute(builderArgument: out _) || method.ReturnType.IsGenericTaskType(compilation)); 182&& method.ReturnType.IsIAsyncEnumerableType(compilation); 191&& method.ReturnType.IsIAsyncEnumeratorType(compilation);

Symbols\OverriddenOrHiddenMembersHelpers.cs (2)

955if (!method.ReturnType.Equals(csharpOverriddenMethod.ReturnType, TypeCompareKind.AllIgnoreOptions))

Symbols\Source\LambdaSymbol.cs (3)

143get { return this.ReturnTypeWithAnnotations.HasType && this.ReturnType.IsVoidType(); } 385&& TypeSymbol.Equals(lambda.ReturnType, this.ReturnType, compareKind)

Symbols\Source\LocalFunctionOrSourceMemberMethodSymbol.cs (1)

29TypeWithAnnotations elementType = InMethodBinder.GetIteratorElementTypeFromReturnType(DeclaringCompilation, RefKind, ReturnType, errorLocation: null, diagnostics: null);

Symbols\Source\LocalFunctionSymbol.cs (1)

311public override bool ReturnsVoid => ReturnType.IsVoidType();

Symbols\Source\SourceComplexParameterSymbol.cs (1)

1227method.ReturnType.OriginalDefinition.Equals(this.DeclaringCompilation.GetWellKnownType(WellKnownType.System_Collections_Generic_IAsyncEnumerable_T)))

Symbols\Source\SourceDelegateMethodSymbol.cs (4)

105diagnostics.Add(ErrorCode.ERR_BadVisDelegateReturn, delegateType.GetFirstLocation(), delegateType, invoke.ReturnType); 109if (!delegateTypeIsFile && invoke.ReturnType.HasFileLocalTypes()) 111diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, delegateType.GetFirstLocation(), invoke.ReturnType, delegateType); 328if (compilation.ShouldEmitNativeIntegerAttributes(ReturnType))

Symbols\Source\SourceMemberContainerSymbol.cs (12)

2862if (!op1.ReturnType.Equals(op2.ReturnType, TypeCompareKind.AllIgnoreOptions)) 4932if (deconstruct.ReturnType.SpecialType != SpecialType.System_Void && !deconstruct.ReturnType.IsErrorType()) 4934diagnostics.Add(ErrorCode.ERR_SignatureMismatchInRecord, deconstruct.GetFirstLocation(), deconstruct, targetMethod.ReturnType); 5040if (!printMembersMethod.ReturnType.Equals(targetMethod.ReturnType, TypeCompareKind.AllIgnoreOptions)) 5042if (!printMembersMethod.ReturnType.IsErrorType()) 5044diagnostics.Add(ErrorCode.ERR_SignatureMismatchInRecord, printMembersMethod.GetFirstLocation(), printMembersMethod, targetMethod.ReturnType); 5363if (thisEquals.ReturnType.SpecialType != SpecialType.System_Boolean && !thisEquals.ReturnType.IsErrorType()) 5365diagnostics.Add(ErrorCode.ERR_SignatureMismatchInRecord, thisEquals.GetFirstLocation(), thisEquals, targetMethod.ReturnType);

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (4)

999if (!IsOrContainsErrorType(overridingMethod.ReturnType)) 1007diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportCovariantReturnsOfClasses, overridingMemberLocation, overridingMember, overriddenMember, overriddenMethod.ReturnType); 1021diagnostics.Add(ErrorCode.ERR_CantChangeReturnTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMethod.ReturnType); 1408method.ReturnType.IsRefLikeOrAllowsRefLikeType() ||

Symbols\Source\SourceMethodSymbolWithAttributes.cs (3)

1395checkAndReportManagedTypes(ReturnType, this.RefKind, returnTypeSyntax, isParam: false, diagnostics); 1580if (ReturnType.OriginalDefinition.Equals(iAsyncEnumerableType) && 1603var returnType = methodSymbol.ReturnType;

Symbols\Source\SourceNamedTypeSymbol.cs (1)

1922TypeSymbol returnType = conversion.ReturnType;

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (2)

233this.ReturnType.CheckAllConstraints(compilation, conversions, this.GetFirstLocation(), diagnostics); 250if (compilation.ShouldEmitNativeIntegerAttributes(ReturnType))

Symbols\Source\SourceOrdinaryMethodSymbol.cs (3)

697if (this.ReturnType?.IsErrorType() == true && GetSyntax().ReturnType is IdentifierNameSyntax { Identifier.RawContextualKind: (int)SyntaxKind.PartialKeyword }) 868else if (ReturnType.IsStatic) 871diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(ContainingType.IsInterfaceType()), location, ReturnType);

Symbols\Source\SourcePropertyAccessorSymbol.cs (1)

323get { return this.ReturnType.IsVoidType(); }

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (5)

636var target = this.ReturnType; 818if (this.ReturnType.SpecialType != SpecialType.System_Boolean) 881this.ReturnType.Equals(parameterType, ComparisonForUserDefinedOperators) : 882((IsInInterfaceAndAbstractOrVirtual() && IsContainingType(parameterType) && IsSelfConstrainedTypeParameter(this.ReturnType)) || 883this.ReturnType.EffectiveTypeNoUseSiteDiagnostics.IsEqualToOrDerivedFrom(parameterType, ComparisonForUserDefinedOperators, useSiteInfo: ref useSiteInfo))))

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (2)

59return f.Return(f.Convert(method.ReturnType, itemFieldReference)); 90method.ReturnType));

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (2)

537interfaceMethod.ReturnType, 697method.ReturnType));

Symbols\Synthesized\Records\SynthesizedRecordClone.cs (2)

114if (ReturnType.IsErrorType()) 181candidate.ReturnType,

Symbols\Synthesized\Records\SynthesizedRecordEqualityContractProperty.cs (1)

173F.CloseMethod(F.Block(F.Return(F.Typeof(ContainingType, ReturnType))));

Symbols\Synthesized\Records\SynthesizedRecordEqualityOperator.cs (1)

46candidate.ReturnType.SpecialType == SpecialType.System_Boolean && !candidate.IsStatic &&

Symbols\Synthesized\Records\SynthesizedRecordEquals.cs (1)

108baseEquals.ReturnType.SpecialType != SpecialType.System_Boolean)

Symbols\Synthesized\Records\SynthesizedRecordGetHashCode.cs (1)

81if (overridden is null || overridden.ReturnType.SpecialType != SpecialType.System_Int32)

Symbols\Synthesized\Records\SynthesizedRecordObjectMethod.cs (2)

48leastOverridden.ReturnType.Equals(overriding.ReturnType, TypeCompareKind.AllIgnoreOptions);

Symbols\Synthesized\Records\SynthesizedRecordObjEquals.cs (1)

47if (_typedRecordEquals.ReturnType.SpecialType != SpecialType.System_Boolean)

Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (2)

123if (ReturnType.IsErrorType() || 158basePrintMethod.ReturnType.SpecialType != SpecialType.System_Boolean)

Symbols\Synthesized\SynthesizedDelegateSymbol.cs (1)

155get { return ReturnType.IsVoidType(); }

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (6)

142get { return ReturnType.IsVoidType(); } 309type: method.ReturnType) 372type: userMain.ReturnType) 379ReturnType.IsVoidType() || 380ReturnType.SpecialType == SpecialType.System_Int32); 491Debug.Assert(!initializer.ReturnType.IsDynamic());

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (1)

243get { return this.ReturnType.IsVoidType(); }

Symbols\TypeSymbol.cs (1)

2027interfaceMemberReturnType = method.ReturnType;

Symbols\VarianceSafety.cs (1)

164method.ReturnType,