ReturnType

Binder\Binder.ValueChecks.cs (2)

53Method is { RefKind: not RefKind.None, ReturnType: { } returnType } && 2883return method.ReturnType.IsRefLikeOrAllowsRefLikeType();

Binder\Binder_Await.cs (6)

41TypeSymbol awaitExpressionType = (info.GetResult ?? info.RuntimeAsyncAwaitCall?.Method)?.ReturnType ?? (hasErrors ? CreateErrorType() : Compilation.DynamicType); 192else if (method.IsIterator && InMethodBinder.IsAsyncStreamInterface(Compilation, method.RefKind, method.ReturnType)) 201info = new CSDiagnosticInfo(ErrorCode.ERR_BadAwaitWithoutAsyncMethod, method.ReturnType); 395method.ReturnType) 441var unsubstitutedReturnType = method.ReturnType; 536runtimeAwaitAwaiterMethod.ReturnType)

Binder\Binder_Conversions.cs (12)

668readonlySpanType.Equals(method.ReturnType.OriginalDefinition, TypeCompareKind.ConsiderEverything)); 719arg.destination.Equals(method.ReturnType.OriginalDefinition, TypeCompareKind.ConsiderEverything) && 725((NamedTypeSymbol)method.ReturnType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(((NamedTypeSymbol)arg.destination).TypeParameters[0], TypeCompareKind.ConsiderEverything)); 748method.ReturnType.Equals(readOnlySpanType, TypeCompareKind.ConsiderEverything)) 1468type: collectionBuilderMethod.ReturnType, 1604conversion = Conversions.ClassifyImplicitConversionFromType(methodWithTargetTypeParameters.ReturnType, targetType.OriginalDefinition, ref candidateUseSiteInfo); 2619TypeSymbol conversionReturnType = conversion.BestUserDefinedConversionAnalysis.Operator.ReturnType; 2749Debug.Assert(TypeSymbol.Equals(destination.StrippedType(), analysis.Operator.MethodKind == MethodKind.Constructor ? analysis.Operator.ContainingType : analysis.Operator.ReturnType, TypeCompareKind.AllIgnoreOptions)); 3596var methodReturnType = method.ReturnType; 3597var delegateReturnType = delegateOrFuncPtrMethod.ReturnType; 3614Error(diagnostics, ErrorCode.ERR_BadRetType, errorLocation, method, method.ReturnType); 3745if ((selectedMethod.HasParameterContainingPointerType() || selectedMethod.ReturnType.ContainsPointerOrFunctionPointer())

Binder\Binder_Crefs.cs (2)

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

Binder\Binder_Deconstruct.cs (1)

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

Binder\Binder_Expressions.cs (2)

4927TypeSymbol constructorReturnType = constructor.ReturnType; 10853getMethod.ReturnType.SpecialType == SpecialType.System_Int32 &&

Binder\Binder_InterpolatedString.cs (1)

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

Binder\Binder_Invocation.cs (3)

1210var returnType = methodResult.Member.ReturnType; 2577funcPtr.Signature.ReturnType, 2600funcPtr.Signature.ReturnType,

Binder\Binder_Operators.cs (2)

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

Binder\Binder_Patterns.cs (1)

371ReturnType.SpecialType: SpecialType.System_Boolean

Binder\Binder_Statements.cs (6)

1304elementType = fixedPatternMethod.ReturnType; 3022TypeSymbol returnType = symbol.ReturnType; 3454lambda.MessageID.Localize(), lambda.ReturnType); 3590var inferringLambda = this.ContainingMemberOrLambda is MethodSymbol method && (object)method.ReturnType == LambdaSymbol.ReturnTypeIsBeingInferred; 4048type: baseConstructor.ReturnType, 4096type: 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 && (moveNextAwaitableInfo.GetResult ?? moveNextAwaitableInfo.RuntimeAsyncAwaitCall?.Method)?.ReturnType.SpecialType != SpecialType.System_Boolean) 539Conversion currentConversionClassification = this.Conversions.ClassifyConversionFromType(builder.CurrentPropertyGetter.ReturnType, builder.ElementType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 541TypeSymbol getEnumeratorType = getEnumeratorMethod.ReturnType; 571builder.CurrentPlaceholder = new BoundValuePlaceholder(_syntax, builder.CurrentPropertyGetter.ReturnType).MakeCompilerGenerated(); 617: builder.PatternDisposeInfo.Method.ReturnType; 1065diagnostics.Add(isAsync ? ErrorCode.ERR_BadGetAsyncEnumerator : ErrorCode.ERR_BadGetEnumerator, collectionSyntax.Location, getEnumeratorMethod.ReturnType, getEnumeratorMethod); 1130TypeSymbol enumeratorType = specificGetEnumeratorMethod.ReturnType; 1189builder.GetEnumeratorInfo.Method.ReturnType.SpecialType == SpecialType.System_Collections_IEnumerator); 1204TypeSymbol enumeratorType = builder.GetEnumeratorInfo.Method.ReturnType; 1325TypeSymbol.Equals(builder.GetEnumeratorInfo.Method.ReturnType, this.Compilation.GetSpecialType(SpecialType.System_Collections_IEnumerator), TypeCompareKind.ConsiderEverything2)); 1646TypeSymbol enumeratorType = getEnumeratorMethod.ReturnType; 1756return moveNextMethodCandidate.OriginalDefinition.ReturnType.SpecialType != SpecialType.System_Boolean;

Binder\InMethodBinder.cs (1)

129TypeSymbol returnType = _methodSymbol.ReturnType;

Binder\LockBinder.cs (1)

90var 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)

274acceptOnlyMethods: true, returnRefKind: delegateInvokeMethodOpt.RefKind, returnType: delegateInvokeMethodOpt.ReturnType, 426returnType: delegateInvokeMethod.ReturnType);

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

1503!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)

1014TypeSymbol resultType = op.ReturnType; 1027TypeSymbol resultType = op.ReturnType; 1550TypeSymbol resultType = method.ReturnType;

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

190TypeSymbol resultType = method.ReturnType; 833TypeSymbol resultType = op.ReturnType; 860TypeSymbol resultType = op.ReturnType;

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

1097var returnType = method.ReturnType; 2461if ((sourceSignature.ReturnType.IsReferenceType || sourceSignature.ReturnType.IsFunctionPointer()) && sourceSignature.RefKind == RefKind.None) 2811if ((sourceSignature.ReturnType.IsReferenceType || sourceSignature.ReturnType.IsFunctionPointer()) && sourceSignature.RefKind == RefKind.None)

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

873if (returnType is null || method.ReturnType.Equals(returnType, TypeCompareKind.AllIgnoreOptions)) 879returnsMatch = Conversions.HasIdentityOrImplicitReferenceConversion(method.ReturnType, returnType, ref useSiteInfo); 882returnsMatch = ConversionsBase.HasImplicitPointerToVoidConversion(method.ReturnType, returnType) 883|| Conversions.HasImplicitPointerConversion(method.ReturnType, returnType, ref useSiteInfo); 3296!(y = invoke.ReturnType).IsVoidType()) 3582TypeSymbol r1 = invoke1.ReturnType; 3583TypeSymbol r2 = invoke2.ReturnType; 3715TypeSymbol r1 = invoke1.ReturnType; 3716TypeSymbol r2 = invoke2.ReturnType;

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

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

Binder\UsingStatementBinder.cs (1)

232awaitableType = disposeMethod.ReturnType;

Binder\WithLambdaParametersBinder.cs (1)

50return lambdaSymbol.ReturnType;

BoundTree\BoundDagEvaluation.cs (1)

346return new BoundDagTemp(Syntax, DeconstructMethod.ReturnType, this, index: -1);

BoundTree\Constructors.cs (2)

161type: method.ReturnType, 232type: method.ReturnType,

BoundTree\UnboundLambda.cs (3)

319var delegateReturnType = delegateType?.GetDelegateType()?.DelegateInvokeMethod?.ReturnType as NamedTypeSymbol; 852(object)LambdaSymbol.InferenceFailureReturnType != lambdaSymbol.ReturnType && 1186var delegateReturnType = invoke.ReturnType as NamedTypeSymbol;

CodeGen\CodeGenerator.cs (1)

330&& ((InternalSpecialType)_method.ReturnType.ExtendedSpecialType) is InternalSpecialType.System_Threading_Tasks_Task or InternalSpecialType.System_Threading_Tasks_ValueTask));

CodeGen\EmitExpression.cs (3)

3736if (!TypeSymbol.Equals(node.Type, getMethod.ReturnType, TypeCompareKind.ConsiderEverything2)) 3763if (!TypeSymbol.Equals(node.Type, getField.ReturnType, TypeCompareKind.ConsiderEverything2)) 4140EmitLoadIndirect(method.ReturnType, syntax);

Compilation\CSharpCompilation.cs (5)

379var methodReturn = method.ReturnType.OriginalDefinition; 2270if (method.ReturnType.IsVoidType() || method.ReturnType.SpecialType == SpecialType.System_Int32) 2275if (!(method.ReturnType is NamedTypeSymbol namedType)) 2317TypeSymbol returnType = method.ReturnType;

Compiler\ClsComplianceChecker.cs (1)

734type = method.ReturnType;

Compiler\MethodCompiler.cs (1)

245var returnType = entryPoint.ReturnType;

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (4)

405var otherReturnType = (TypeSymbol?)Visit(sig.ReturnType); 615return _comparer.Equals(method.ReturnType, other.ReturnType) && 926var 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)

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

FlowAnalysis\NullableWalker.cs (8)

3859invokeMethod.ReturnType.Equals(l.ReturnType, TypeCompareKind.AllNullableIgnoreOptions | TypeCompareKind.IgnoreTupleNames); 7107|| method.ReturnType.SpecialType != SpecialType.System_Boolean 7989if (method.ReturnType.SpecialType == SpecialType.System_Boolean) 10605Debug.Assert(TypeSymbol.Equals(targetTypeWithNullability.Type.StrippedType(), analysis.Operator.MethodKind == MethodKind.Constructor ? analysis.Operator.ContainingType : analysis.Operator.ReturnType, TypeCompareKind.AllIgnoreOptions)); 12542var moveNextAsyncMethod = (MethodSymbol)AsMemberOfType(reinferredGetEnumeratorMethod.ReturnType, enumeratorInfoOpt.MoveNextInfo.Method); 12556patternDisposeMethod = (MethodSymbol)AsMemberOfType(reinferredGetEnumeratorMethod.ReturnType, patternDisposeMethod); 13607method.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)

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

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

130if (ReturnType.ContainsNativeIntegerWrapperType())

Lowering\IteratorRewriter\IteratorRewriter.cs (2)

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

Lowering\LocalRewriter\LocalRewriter.cs (1)

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

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

196Debug.Assert(method.ReturnType.SpecialType == SpecialType.System_Boolean); 263TypeSymbol type = e.Property.GetMethod.ReturnType;

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (1)

443setMethod.ReturnType);

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (3)

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

Lowering\LocalRewriter\LocalRewriter_Call.cs (4)

487method.ReturnType); 505type: method.ReturnType); 522method.ReturnType); 1537type: arrayEmpty.ReturnType);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (2)

210if (getEnumeratorMethod?.ReturnType.IsValueType == true) 236(!builder.ReturnType.IsRefLikeType || parameter.EffectiveScope == ScopedKind.ScopedValue))

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (9)

675if (Binder.TryFindCastUpMethod(implicitOperator.ReturnType.OriginalDefinition, destinationType.OriginalDefinition) is not { } castUpMethodDefinition) 912TypeSymbol userDefinedConversionRewrittenType = conversion.Method.ReturnType; 964Debug.Assert(TypeSymbol.Equals(rewrittenType.StrippedType(), analysis.Operator.MethodKind == MethodKind.Constructor ? analysis.Operator.ContainingType : analysis.Operator.ReturnType, TypeCompareKind.AllIgnoreOptions)); 1454if (call.Method.ReturnType.IsValidNullableTypeArgument()) 1456Debug.Assert(resultType.IsNullableType() && TypeSymbol.Equals(resultType.GetNullableUnderlyingType(), call.Method.ReturnType, TypeCompareKind.ConsiderEverything2)); 1586receiverOpt: new BoundTypeExpression(syntax, aliasOpt: null, conversion.Method.ReturnType), 1861Debug.Assert(TypeSymbol.Equals(method.ReturnType, toType, TypeCompareKind.ConsiderEverything2)); 1885Conversion toConversion = TryMakeConversion(syntax, conversion.UserDefinedToConversion, meth.ReturnType, toType, @checked: @checked); 1998Conversion 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)

158TypeSymbol enumeratorType = getEnumeratorInfo.Method.ReturnType; 238rewrittenCondition = RewriteAwaitExpression(forEachSyntax, rewrittenCondition, moveNextAwaitableInfo, (moveNextAwaitableInfo.GetResult ?? moveNextAwaitableInfo.RuntimeAsyncAwaitCall!.Method)!.ReturnType, debugInfo, used: true); 487TypeSymbol awaitExpressionType = disposeAwaitableInfoOpt.GetResult?.ReturnType ?? _compilation.DynamicType;

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (6)

284getItemOrSliceHelper = getItemOrSliceHelper.AsMember((NamedTypeSymbol)createSpan.ReturnType); 456getItemOrSliceHelper = getItemOrSliceHelper.AsMember((NamedTypeSymbol)createSpan.ReturnType); 1101&& startLengthOverload.ReturnType.Equals(startOverload.ReturnType, TypeCompareKind.ConsiderEverything)); 1142&& startLengthOverload.ReturnType.Equals(startOverload.ReturnType, TypeCompareKind.ConsiderEverything));

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (1)

579BoundExpression 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)); 803Debug.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)

574var conversion = Compilation.Conversions.ClassifyConversionFromType(expression.Type, CurrentFunction.ReturnType, isChecked: false, ref useSiteInfo); 581expression = BoundConversion.Synthesized(Syntax, expression, conversion, false, explicitCastInCode: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, ConstantValue.NotAvailable, CurrentFunction.ReturnType); 889type: method.ReturnType, hasErrors: method.OriginalDefinition is ErrorMethodSymbol) 929argsToParamsOpt: ImmutableArray<int>.Empty, defaultArguments: default(BitVector), resultKind: LookupResultKind.Viable, type: method.ReturnType) 1303Debug.Assert(TypeSymbol.Equals(systemType, getTypeFromHandle.ReturnType, TypeCompareKind.AllIgnoreOptions)); 1347Debug.Assert(result.Type.IsErrorType() || result.Type!.IsDerivedFrom(result.GetMethodFromHandle!.ReturnType, TypeCompareKind.AllIgnoreOptions, ref discardedUseSiteInfo)); 1454Debug.Assert(result.Type.IsErrorType() || result.Type!.IsDerivedFrom(result.GetMethodFromHandle!.ReturnType, TypeCompareKind.AllIgnoreOptions, ref discardedUseSiteInfo));

Operations\CSharpOperationFactory.cs (1)

1977HasImplicitConversionToOrImplementsVarianceCompatibleInterface(enumeratorInfoOpt.GetEnumeratorInfo.Method.ReturnType,

Symbols\Compilation_WellKnownMembers.cs (1)

1195return 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)

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

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

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

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

652public override bool ReturnsVoid => this.ReturnType.IsVoidType(); 1834return this.HasParameterContainingPointerType() || ReturnType.ContainsPointerOrFunctionPointer();

Symbols\MethodSymbol.cs (2)

468(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\NamedTypeSymbol.cs (1)

1970unionType.Equals(factory.ReturnType, TypeCompareKind.AllIgnoreOptions);

Symbols\OverriddenOrHiddenMembersHelpers.cs (2)

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

Symbols\Source\LambdaSymbol.cs (3)

147get { return this.ReturnTypeWithAnnotations.HasType && this.ReturnType.IsVoidType(); } 401&& 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)

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

Symbols\Source\SourceComplexParameterSymbol.cs (1)

1270method.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); 333if (compilation.ShouldEmitNativeIntegerAttributes(ReturnType))

Symbols\Source\SourceMemberContainerSymbol.cs (12)

2991if (!op1.ReturnType.Equals(op2.ReturnType, TypeCompareKind.AllIgnoreOptions)) 5169if (deconstruct.ReturnType.SpecialType != SpecialType.System_Void && !deconstruct.ReturnType.IsErrorType()) 5171diagnostics.Add(ErrorCode.ERR_SignatureMismatchInRecord, deconstruct.GetFirstLocation(), deconstruct, targetMethod.ReturnType); 5277if (!printMembersMethod.ReturnType.Equals(targetMethod.ReturnType, TypeCompareKind.AllIgnoreOptions)) 5279if (!printMembersMethod.ReturnType.IsErrorType()) 5281diagnostics.Add(ErrorCode.ERR_SignatureMismatchInRecord, printMembersMethod.GetFirstLocation(), printMembersMethod, targetMethod.ReturnType); 5600if (thisEquals.ReturnType.SpecialType != SpecialType.System_Boolean && !thisEquals.ReturnType.IsErrorType()) 5602diagnostics.Add(ErrorCode.ERR_SignatureMismatchInRecord, thisEquals.GetFirstLocation(), thisEquals, targetMethod.ReturnType);

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (4)

1022if (!IsOrContainsErrorType(overridingMethod.ReturnType)) 1030diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportCovariantReturnsOfClasses, overridingMemberLocation, overridingMember, overriddenMember, overriddenMethod.ReturnType); 1044diagnostics.Add(ErrorCode.ERR_CantChangeReturnTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMethod.ReturnType); 1439method.ReturnType.IsRefLikeOrAllowsRefLikeType() ||

Symbols\Source\SourceMethodSymbol.cs (1)

128return this.HasParameterContainingPointerType() || ReturnType.ContainsPointerOrFunctionPointer()

Symbols\Source\SourceMethodSymbolWithAttributes.cs (3)

1411checkAndReportManagedTypes(ReturnType, this.RefKind, returnTypeSyntax, isParam: false, diagnostics); 1596if (ReturnType.OriginalDefinition.Equals(iAsyncEnumerableType) && 1619var returnType = methodSymbol.ReturnType;

Symbols\Source\SourceNamedTypeSymbol.cs (1)

2019TypeSymbol returnType = conversion.ReturnType;

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (2)

236this.ReturnType.CheckAllConstraints(compilation, conversions, this.GetFirstLocation(), diagnostics); 253if (compilation.ShouldEmitNativeIntegerAttributes(ReturnType))

Symbols\Source\SourceOrdinaryMethodSymbol.cs (3)

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

Symbols\Source\SourcePropertyAccessorSymbol.cs (1)

353get { 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 (4)

59Debug.Assert(method.ReturnType.IsObjectType()); 62Conversion c = f.ClassifyEmitConversion(itemFieldReference, method.ReturnType); 67return f.Return(f.Convert(method.ReturnType, itemFieldReference, c)); 98method.ReturnType));

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

543TypeSymbol returnType = interfaceMethod.ReturnType; 731method.ReturnType));

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

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

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

182F.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)

48if (_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)

158get { return ReturnType.IsVoidType(); }

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (9)

142get { return ReturnType.IsVoidType(); } 311type: method.ReturnType) 379type: userMain.ReturnType) 383var specialMember = userMain.ReturnType.IsGenericTaskType(compilation) 388&& handleAsyncEntryPointMethod.Parameters[0].Type.Equals(userMain.ReturnType, TypeCompareKind.AllIgnoreOptions)) 405type: handleAsyncEntryPointMethod.ReturnType) 416ReturnType.IsVoidType() || 417ReturnType.SpecialType == SpecialType.System_Int32); 529Debug.Assert(!initializer.ReturnType.IsDynamic());

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (1)

57delegateInvoke.ReturnType.SpecialType != SpecialType.System_Void ||

Symbols\TypeSymbol.cs (1)

2036interfaceMemberReturnType = method.ReturnType;

Symbols\VarianceSafety.cs (1)

164method.ReturnType,