protected MethodSymbol VisitMethodSymbol(MethodSymbol method) { if ((object)method == null) { return(null); } if (!method.ContainingType.IsAnonymousType) { // Method of a regular type return(((MethodSymbol)method.OriginalDefinition) .AsMember((NamedTypeSymbol)TypeMap.SubstituteType(method.ContainingType).AsTypeSymbolOnly()) .ConstructIfGeneric(TypeMap.SubstituteTypesWithoutModifiers(method.TypeArguments))); } // Method of an anonymous type var newType = (NamedTypeSymbol)TypeMap.SubstituteType(method.ContainingType).AsTypeSymbolOnly(); if (ReferenceEquals(newType, method.ContainingType)) { // Anonymous type symbol was not rewritten return(method); } // get a new method by name foreach (var member in newType.GetMembers(method.Name)) { if (member.Kind == SymbolKind.Method) { return((MethodSymbol)member); } } throw ExceptionUtilities.Unreachable; }
private BoundNode RewriteMethodGroupConversion(BoundConversion conversion) { // in a method group conversion, we may need to rewrite the selected method BoundMethodGroup operand = (BoundMethodGroup)conversion.Operand; BoundExpression originalReceiverOpt = operand.ReceiverOpt; BoundExpression receiverOpt; if (originalReceiverOpt == null) { receiverOpt = null; } else if (!conversion.IsExtensionMethod && conversion.SymbolOpt.IsStatic) { receiverOpt = new BoundTypeExpression(originalReceiverOpt.Syntax, null, VisitType(originalReceiverOpt.Type)); } else { receiverOpt = (BoundExpression)Visit(originalReceiverOpt); } TypeSymbol type = this.VisitType(conversion.Type); MethodSymbol method = conversion.SymbolOpt; // if the original receiver was a base access and is was rewritten, // change the method to point to the wrapper method if (BaseReferenceInReceiverWasRewritten(originalReceiverOpt, receiverOpt) && method.IsMetadataVirtual()) { method = GetMethodWrapperForBaseNonVirtualCall(method, conversion.Syntax); } method = VisitMethodSymbol(method); operand = operand.Update( TypeMap.SubstituteTypesWithoutModifiers(operand.TypeArgumentsOpt), method.Name, operand.Methods, operand.LookupSymbolOpt, operand.LookupError, operand.Flags, receiverOpt, operand.ResultKind); var conversionInfo = conversion.Conversion; if (conversionInfo.Method != (object)method) { conversionInfo = conversionInfo.SetConversionMethod(method); } return(conversion.Update( operand, conversionInfo, isBaseConversion: conversion.IsBaseConversion, @checked: conversion.Checked, explicitCastInCode: conversion.ExplicitCastInCode, constantValueOpt: conversion.ConstantValueOpt, type: type)); }
private ReducedExtensionMethodSymbol(MethodSymbol reducedFrom) { Debug.Assert((object)reducedFrom != null); Debug.Assert(reducedFrom.IsExtensionMethod); Debug.Assert((object)reducedFrom.ReducedFrom == null); Debug.Assert(reducedFrom.ConstructedFrom == reducedFrom); Debug.Assert(reducedFrom.ParameterCount > 0); _reducedFrom = reducedFrom; _typeMap = TypeMap.Empty.WithAlphaRename(reducedFrom, this, out _typeParameters); _typeArguments = _typeMap.SubstituteTypesWithoutModifiers(reducedFrom.TypeArguments); }
private ReducedExtensionMethodSymbol(MethodSymbol reducedFrom) { Debug.Assert((object)reducedFrom != null); Debug.Assert(reducedFrom.IsExtensionMethod); Debug.Assert((object)reducedFrom.ReducedFrom == null); Debug.Assert(reducedFrom.ConstructedFrom == reducedFrom); Debug.Assert(reducedFrom.ParameterCount > 0); _reducedFrom = reducedFrom; _typeMap = TypeMap.Empty.WithAlphaRename(reducedFrom, this, out _typeParameters); _typeArguments = _typeMap.SubstituteTypesWithoutModifiers(reducedFrom.TypeArguments); }
protected MethodSymbol VisitMethodSymbol(MethodSymbol method) { if ((object)method == null) { return(null); } if (method.IsTupleMethod) { // Method of a tuple type var oldType = method.ContainingType; var constructedFrom = method.ConstructedFrom; Debug.Assert(oldType.IsTupleType); var newType = (NamedTypeSymbol)TypeMap.SubstituteType(oldType).AsTypeSymbolOnly(); if ((object)newType == oldType) { // tuple type symbol was not rewritten return(constructedFrom.ConstructIfGeneric(TypeMap.SubstituteTypesWithoutModifiers(method.TypeArguments))); } Debug.Assert(newType.IsTupleType); Debug.Assert(oldType.TupleElementTypes.Length == newType.TupleElementTypes.Length); // get a new method by position var oldMembers = oldType.GetMembers(); var newMembers = newType.GetMembers(); Debug.Assert(oldMembers.Length == newMembers.Length); for (int i = 0; i < oldMembers.Length; i++) { if ((object)constructedFrom == oldMembers[i]) { return(((MethodSymbol)newMembers[i]).ConstructIfGeneric(TypeMap.SubstituteTypesWithoutModifiers(method.TypeArguments))); } } throw ExceptionUtilities.Unreachable; } else if (method.ContainingType.IsAnonymousType) { // Method of an anonymous type var newType = (NamedTypeSymbol)TypeMap.SubstituteType(method.ContainingType).AsTypeSymbolOnly(); if (ReferenceEquals(newType, method.ContainingType)) { // Anonymous type symbol was not rewritten return(method); } // get a new method by name foreach (var member in newType.GetMembers(method.Name)) { if (member.Kind == SymbolKind.Method) { return((MethodSymbol)member); } } throw ExceptionUtilities.Unreachable; } else { // Method of a regular type return(((MethodSymbol)method.OriginalDefinition) .AsMember((NamedTypeSymbol)TypeMap.SubstituteType(method.ContainingType).AsTypeSymbolOnly()) .ConstructIfGeneric(TypeMap.SubstituteTypesWithoutModifiers(method.TypeArguments))); } }
internal override ImmutableArray <TypeSymbol> GetConstraintTypes(ConsList <TypeParameterSymbol> inProgress) { return(_map.SubstituteTypesWithoutModifiers(_substitutedFrom.GetConstraintTypes(inProgress)).WhereAsArray(s_isNotObjectFunc).Distinct()); }