// // Infers type arguments based on explicit arguments // public bool ExplicitTypeInference (ResolveContext ec, TypeInferenceContext type_inference, TypeSpec delegate_type) { if (!HasExplicitParameters) return false; if (!delegate_type.IsDelegate) { if (!delegate_type.IsExpressionTreeType) return false; delegate_type = TypeManager.GetTypeArguments (delegate_type) [0]; if (!delegate_type.IsDelegate) return false; } AParametersCollection d_params = Delegate.GetParameters (delegate_type); if (d_params.Count != Parameters.Count) return false; var ptypes = Parameters.Types; var dtypes = d_params.Types; for (int i = 0; i < Parameters.Count; ++i) { if (type_inference.ExactInference (ptypes[i], dtypes[i]) == 0) { // // Continue when 0 (quick path) does not mean inference failure. Checking for // same type handles cases like int -> int // if (ptypes[i] == dtypes[i]) continue; return false; } } return true; }
// // Implements method type arguments inference // bool InferInPhases (ResolveContext ec, TypeInferenceContext tic, AParametersCollection methodParameters) { int params_arguments_start; if (methodParameters.HasParams) { params_arguments_start = methodParameters.Count - 1; } else { params_arguments_start = arg_count; } TypeSpec [] ptypes = methodParameters.Types; // // The first inference phase // TypeSpec method_parameter = null; for (int i = 0; i < arg_count; i++) { Argument a = arguments [i]; if (a == null) continue; if (i < params_arguments_start) { method_parameter = methodParameters.Types [i]; } else if (i == params_arguments_start) { if (arg_count == params_arguments_start + 1 && TypeManager.HasElementType (a.Type)) method_parameter = methodParameters.Types [params_arguments_start]; else method_parameter = TypeManager.GetElementType (methodParameters.Types [params_arguments_start]); ptypes = (TypeSpec[]) ptypes.Clone (); ptypes [i] = method_parameter; } // // When a lambda expression, an anonymous method // is used an explicit argument type inference takes a place // AnonymousMethodExpression am = a.Expr as AnonymousMethodExpression; if (am != null) { if (am.ExplicitTypeInference (ec, tic, method_parameter)) --score; continue; } if (a.IsByRef) { score -= tic.ExactInference (a.Type, method_parameter); continue; } if (a.Expr.Type == InternalType.Null) continue; if (TypeManager.IsValueType (method_parameter)) { score -= tic.LowerBoundInference (a.Type, method_parameter); continue; } // // Otherwise an output type inference is made // score -= tic.OutputTypeInference (ec, a.Expr, method_parameter); } // // Part of the second phase but because it happens only once // we don't need to call it in cycle // bool fixed_any = false; if (!tic.FixIndependentTypeArguments (ec, ptypes, ref fixed_any)) return false; return DoSecondPhase (ec, tic, ptypes, !fixed_any); }
// // Infers type arguments based on explicit arguments // public bool ExplicitTypeInference (ResolveContext ec, TypeInferenceContext type_inference, TypeSpec delegate_type) { if (!HasExplicitParameters) return false; if (!delegate_type.IsDelegate) { if (!delegate_type.IsExpressionTreeType) return false; delegate_type = TypeManager.GetTypeArguments (delegate_type) [0]; if (!delegate_type.IsDelegate) return false; } AParametersCollection d_params = Delegate.GetParameters (delegate_type); if (d_params.Count != Parameters.Count) return false; for (int i = 0; i < Parameters.Count; ++i) { TypeSpec itype = d_params.Types [i]; if (!TypeManager.IsGenericParameter (itype)) { if (!TypeManager.HasElementType (itype)) continue; if (!TypeManager.IsGenericParameter (TypeManager.GetElementType (itype))) continue; } type_inference.ExactInference (Parameters.Types [i], itype); } return true; }
// // Infers type arguments based on explicit arguments // public bool ExplicitTypeInference (TypeInferenceContext type_inference, Type delegate_type) { if (!HasExplicitParameters) return false; if (!TypeManager.IsDelegateType (delegate_type)) { #if GMCS_SOURCE if (TypeManager.DropGenericTypeArguments (delegate_type) != TypeManager.expression_type) return false; delegate_type = delegate_type.GetGenericArguments () [0]; if (!TypeManager.IsDelegateType (delegate_type)) return false; #else return false; #endif } AParametersCollection d_params = TypeManager.GetDelegateParameters (delegate_type); if (d_params.Count != Parameters.Count) return false; for (int i = 0; i < Parameters.Count; ++i) { Type itype = d_params.Types [i]; if (!TypeManager.IsGenericParameter (itype)) { if (!TypeManager.HasElementType (itype)) continue; if (!TypeManager.IsGenericParameter (itype.GetElementType ())) continue; } type_inference.ExactInference (Parameters.Types [i], itype); } return true; }