62return this._parameters.Select(p => new KeyValuePair<string, TypeUsage>(p.ParameterName, p.ResultType));

86return this._parameters.Select(p => new KeyValuePair<string, TypeUsage>(p.ParameterName, p.ResultType));

187TypeUsage newVarType = this.VisitTypeUsage(varRef.ResultType); 188if (!object.ReferenceEquals(varRef.ResultType, newVarType)) 326TypeUsage newType = this.VisitTypeUsage(expression.ResultType); 327if (!object.ReferenceEquals(expression.ResultType, newType)) 348!object.ReferenceEquals(from.ResultType.EdmType, to.ResultType.EdmType) || 349!from.ResultType.EdmEquals(to.ResultType)) 543if(TypeSemantics.IsRowType(exp.ResultType)) 676return this.VisitTypeUnary(expression, expression.ResultType, CqtBuilder.TreatAs); 697return this.VisitTypeUnary(expression, expression.ResultType, CqtBuilder.CastTo); 739TypeUsage newType = this.VisitTypeUsage(expression.ResultType); 741bool unchanged = (object.ReferenceEquals(expression.ResultType, newType) && object.ReferenceEquals(expression.Arguments, newArguments)); 768EntityType targetType = (EntityType)TypeHelpers.GetEdmType<RefType>(expression.ResultType).ElementType; 972TypeHelpers.GetEdmType<RowType>(TypeHelpers.GetEdmType<CollectionType>(expression.ResultType).TypeUsage);

60public TypeUsage VariableType { get { return _varRef.ResultType; } } 102public TypeUsage VariableType { get { return _varRef.ResultType; } } 117public TypeUsage GroupVariableType { get { return _groupVarRef.ResultType; } }

187TypeUsage resultType = TypeHelpers.CreateCollectionTypeUsage(argument.ResultType); 517return new DbSkipExpression(input.Expression.ResultType, input, validSortOrder, count); 536return new DbSortExpression(input.Expression.ResultType, input, validSortOrder); 964DbExpression escape = DbExpressionBuilder.Null(pattern.ResultType);

61argumentTypes[idx] = arguments[idx].ResultType;

52if (!TypeSemantics.IsStructurallyEqualOrPromotableTo(expression.ResultType, requiredResultType)) 61TypeHelpers.GetFullName(expression.ResultType), 79bool valueIsPrimitive = TypeHelpers.TryGetPrimitiveTypeKind(expression.ResultType, out valueTypeKind); 92: TypeHelpers.GetFullName(expression.ResultType)), 119if (TypeHelpers.GetCommonTypeUsage(endType, from.ResultType) == null) 124else if (!TypeSemantics.IsStructurallyEqualOrPromotableTo(from.ResultType.EdmType, endType.EdmType)) 134if (!TypeSemantics.IsCollectionType(argument.ResultType)) 144if (!TypeSemantics.IsCollectionType(left.ResultType) || !TypeSemantics.IsCollectionType(right.ResultType)) 149TypeUsage commonType = TypeHelpers.GetCommonTypeUsage(left.ResultType, right.ResultType); 162if (!TypeHelpers.IsSetComparableOpType(TypeHelpers.GetElementTypeUsage(left.ResultType))) 164throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_InvalidTypeForSetOperation(TypeHelpers.GetElementTypeUsage(left.ResultType).Identity, typeof(TExpressionType).Name), "left"); 167if (!TypeHelpers.IsSetComparableOpType(TypeHelpers.GetElementTypeUsage(right.ResultType))) 169throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_InvalidTypeForSetOperation(TypeHelpers.GetElementTypeUsage(right.ResultType).Identity, typeof(TExpressionType).Name), "right"); 232return TypeHelpers.GetCommonTypeUsage(left.ResultType, right.ResultType); 268if (!TypeHelpers.TryGetCollectionElementType(input.ResultType, out elementType)) 304if (!TypeHelpers.TryGetCollectionElementType(input.ResultType, out elementType)) 365if (!TypeHelpers.IsValidSortOpKeyType(key.ResultType)) 381if (!TypeSemantics.IsPrimitiveType(key.ResultType, PrimitiveTypeKind.String)) 438return predicate.ResultType; 558return input.Expression.ResultType; 585if (!TypeHelpers.IsValidGroupKeyType(keyInfo.Value.ResultType)) 591columns.Add(new KeyValuePair<string, TypeUsage>(keyInfo.Key, keyInfo.Value.ResultType)); 656return CreateCollectionResultType(projection.ResultType); 688if (!TypeSemantics.IsIntegerNumericType(count.ResultType)) 859if (!TypeSemantics.IsPrimitiveType(argument.ResultType, PrimitiveTypeKind.Boolean)) 864return argument.ResultType; 874resultType = argument.ResultType; 881if (TypeSemantics.IsUnsignedNumericType(argument.ResultType)) 884if (TypeHelpers.TryGetClosestPromotableType(argument.ResultType, out closestPromotableType)) 890throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Arithmetic_InvalidUnsignedTypeForUnaryMinus(argument.ResultType.EdmType.FullName)); 924equality = TypeSemantics.IsEqualComparableTo(left.ResultType, right.ResultType); 925order = TypeSemantics.IsOrderComparableTo(left.ResultType, right.ResultType); 930equality = TypeSemantics.IsEqualComparableTo(left.ResultType, right.ResultType); 934order = TypeSemantics.IsOrderComparableTo(left.ResultType, right.ResultType); 957if (TypeSemantics.IsCollectionType(argument.ResultType)) 965if (!TypeHelpers.IsValidIsNullOpType(argument.ResultType)) 968if (!allowRowType || !TypeSemantics.IsRowType(argument.ResultType)) 1009if (!TypeSemantics.IsCastAllowed(argument.ResultType, toType)) 1011throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Cast_InvalidCast(TypeHelpers.GetFullName(argument.ResultType), TypeHelpers.GetFullName(toType))); 1027if (!TypeSemantics.IsValidPolymorphicCast(argument.ResultType, asType)) 1052if (!TypeHelpers.TryGetCollectionElementType(argument.ResultType, out elementType) || 1077if (!TypeSemantics.IsValidPolymorphicCast(argument.ResultType, type)) 1097if (!TypeHelpers.TryGetRefEntityType(argument.ResultType, out entityType)) 1113if (!TypeHelpers.TryGetEdmType<EntityType>(argument.ResultType, out entityType) || null == entityType) 1203if (!TypeHelpers.TryGetEdmType<RefType>(argument.ResultType, out refType) || null == refType) 1297CollectionType inputType = TypeHelpers.GetEdmType<CollectionType>(argument.ResultType); 1303return argument.ResultType; 1318return TypeHelpers.GetEdmType<CollectionType>(argument.ResultType).TypeUsage; 1342return left.ResultType; 1379if (!TypeSemantics.IsIntegerNumericType(limit.ResultType)) 1401return argument.ResultType; 1430commonResultType = exp.ResultType; 1434commonResultType = TypeHelpers.GetCommonTypeUsage(exp.ResultType, commonResultType); 1444commonResultType = TypeHelpers.GetCommonTypeUsage(elseExpression.ResultType, commonResultType); 1513RequireCompatibleType(exp, lambda.Variables[idx].ResultType, "arguments", idx); 1522return lambda.Body.ResultType; 1532commonElementType = exp.ResultType; 1536commonElementType = TypeSemantics.GetCommonType(commonElementType, exp.ResultType); 1575columnTypes.Add(new KeyValuePair<string, TypeUsage>(columnValue.Key, columnValue.Value.ResultType)); 1715if (TypeHelpers.TryGetEdmType<StructuralType>(instance.ResultType, out structType)) 1735throw EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.Cqt_Factory_NoSuchProperty(propertyName, TypeHelpers.GetFullName(instance.ResultType)), "propertyName"); 2057TypeSemantics.IsIntegerNumericType(expression.ResultType) &&

202StructuralType declType = instance.ResultType.EdmType as StructuralType; 228throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_EndNotFound(expression.Property.Name, TypeHelpers.GetFullName(newInstance.ResultType.EdmType))); 237throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_NavPropertyNotFound(expression.Property.Name, TypeHelpers.GetFullName(newInstance.ResultType.EdmType))); 246throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_PropertyNotFound(expression.Property.Name, TypeHelpers.GetFullName(newInstance.ResultType.EdmType)));

361Dump(expr.ResultType, "ResultType");

178_key.Append(e.ResultType.Identity); 191Debug.Assert(TypeSemantics.IsScalarType(e.ResultType), "Non-scalar type constant expressions are not supported."); 192var primitive = TypeHelpers.GetPrimitiveTypeUsageForScalar(e.ResultType); 290_key.Append(e.ResultType.Identity); 296_key.Append(e.ResultType.Identity); 311_key.Append(e.ResultType.Identity); 327_key.Append(v.ResultType.Identity); 495_key.Append(e.ResultType.EdmType.Identity); 530_key.Append(TypeHelpers.GetEdmType<RefType>(e.ResultType).ElementType.FullName); 573_key.Append(e.ResultType.EdmType.Identity);

192PrinterVisitor.AppendTypeSpecifier(queryNode, tree.Query.ResultType); 461AppendTypeSpecifier(retInfo, expr.ResultType); 540AppendParameters(lambdaInfo, expression.Lambda.Variables.Select(v => new KeyValuePair<string, TypeUsage>(v.VariableName, v.ResultType))); 685AppendType(argInfo, e.ResultType); 693AppendTypeSpecifier(retInfo, e.ResultType); 754AppendTypeSpecifier(retInfo, e.ResultType); 756if (BuiltInTypeKind.CollectionType == e.ResultType.EdmType.BuiltInTypeKind) 765string description = (BuiltInTypeKind.RowType == e.ResultType.EdmType.BuiltInTypeKind) ? "Column" : "Property"; 766IList<EdmProperty> properties = TypeHelpers.GetProperties(e.ResultType); 772if (BuiltInTypeKind.EntityType == e.ResultType.EdmType.BuiltInTypeKind && 795AppendFullName(retNode.Text, TypeHelpers.GetEdmType<RefType>(e.ResultType).ElementType); 909RowType outputType = TypeHelpers.GetEdmType<RowType>(TypeHelpers.GetEdmType<CollectionType>(e.ResultType).TypeUsage);

188internal static Func<DbExpression, bool> MatchComplexType { get { return (e => TypeSemantics.IsComplexType(e.ResultType)); } } 193internal static Func<DbExpression, bool> MatchEntityType { get { return (e => TypeSemantics.IsEntityType(e.ResultType)); } } 198internal static Func<DbExpression, bool> MatchRowType { get { return (e => TypeSemantics.IsRowType(e.ResultType)); } }

78var newScope = scopeVariables.ToDictionary(var => var.VariableName, var => var.ResultType, StringComparer.Ordinal); 108if (!TypeSemantics.IsEqual(varRef.ResultType, foundType)) 128if (!TypeSemantics.IsEqual(paramRef.ResultType, foundParam.ResultType))

221EntityType constructedEntityType = TypeHelpers.GetEdmType<EntityType>(entityConstructor.ResultType); 441RowType resultRow = TypeHelpers.GetEdmType<RowType>(rowConstructor.ResultType); 457!TypeSemantics.IsBooleanType(casePredicate.Then[0].ResultType) || !TypeSemantics.IsBooleanType(casePredicate.Else.ResultType) || 639TypeUsage innerResultTypeUsage = innerNew.ResultType; 828expression.ResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType) 834var primitiveType = (PrimitiveType)expression.ResultType.EdmType;

239Debug.Assert(TypeSemantics.IsCastAllowed(argument.ResultType, type), "DbCastExpression represents an invalid cast"); 460Debug.Assert(TypeSemantics.IsValidPolymorphicCast(argument.ResultType, asType), "DbTreatExpression represents an invalid treat"); 496Debug.Assert(TypeSemantics.IsPrimitiveType(input.ResultType, PrimitiveTypeKind.String), "DbLikeExpression argument must have a string result type"); 497Debug.Assert(TypeSemantics.IsPrimitiveType(pattern.ResultType, PrimitiveTypeKind.String), "DbLikeExpression pattern must have a string result type"); 498Debug.Assert(TypeSemantics.IsPrimitiveType(escape.ResultType, PrimitiveTypeKind.String), "DbLikeExpression escape must have a string result type");

81Debug.Assert(TypeSemantics.IsCollectionType(argument.ResultType), "DbDistinctExpression argument must have a collection result type"); 160Debug.Assert(object.ReferenceEquals(resultType, left.ResultType), "DbExceptExpression result type should be result type of left argument"); 194Debug.Assert(TypeSemantics.IsPrimitiveType(predicate.ResultType, PrimitiveTypeKind.Boolean), "DbFilterExpression predicate must have a Boolean result type"); 428Debug.Assert(object.ReferenceEquals(resultType, argument.ResultType), "DbLimitExpression result type must be the result type of the argument"); 528Debug.Assert(TypeSemantics.IsPrimitiveType(predicate.ResultType, PrimitiveTypeKind.Boolean), "DbQuantifierExpression predicate must have a Boolean result type");

330Debug.Assert(object.ReferenceEquals(resultType, lambda.Body.ResultType), "DbLambdaExpression result type must be Lambda body result type"); 593if (!TypeSemantics.IsReferenceType(targetEntityRef.ResultType)) 600EntityTypeBase targetType = TypeHelpers.GetEdmType<RefType>(targetEntityRef.ResultType).ElementType;

114TypeHelpers.AssertEdmType(lambda.Body.ResultType);

309ValidateQueryResultType(converted.ResultType, queryStatement.Expr.ErrCtx); 588leftExpr = DbExpressionBuilder.Null(rightExpr.ResultType); 593rightExpr = DbExpressionBuilder.Null(leftExpr.ResultType); 756ValidateDistinctProjection(definition.ResultType, groupAggregateExpr.ArgExpr.ErrCtx, null); 937(varRef) => varRef.ResultType, 961ConvertUntypedNullsInArguments(args, overload.Parameters, (formal) => formal.ResultType); 1372bool isPromotable = TypeSemantics.IsPromotableTo(args[idx].ResultType, memberModelTypeUsage); 1376if (!isPromotable && !TypeSemantics.IsPromotableTo(memberModelTypeUsage, args[idx].ResultType)) 1380args[idx].ResultType.EdmType.FullName, 1386!TypeSemantics.IsSubTypeOf(args[idx].ResultType, memberModelTypeUsage)) 1397args[idx].ResultType.EdmType.FullName, 1512argTypes = convertedArgs.Select(a => a != null ? a.ResultType : null).ToList(); 1574var refType = targetEntityRef.ResultType.EdmType as RefType; 1691var sourceRefType = sourceEntityRef.ResultType.EdmType as RefType; 1694var entityType = sourceEntityRef.ResultType.EdmType as EntityType; 1698sourceRefType = (RefType)sourceEntityRef.ResultType.EdmType; 1805if (!TypeSemantics.IsEntityType(converted.ResultType)) 1807throw EntityUtil.EntitySqlError(refExpr.ArgExpr.ErrCtx, Strings.RefArgIsNotOfEntityType(converted.ResultType.EdmType.FullName)); 1833if (!TypeSemantics.IsReferenceType(converted.ResultType)) 1835throw EntityUtil.EntitySqlError(deRefExpr.ArgExpr.ErrCtx, Strings.DeRefArgIsNotOfRefType(converted.ResultType.EdmType.FullName)); 1876RowType inputKeyRowType = keyRowExpression.ResultType.EdmType as RowType; 1889if (!TypeSemantics.IsStructurallyEqualOrPromotableTo(keyRowExpression.ResultType, TypeUsage.Create(entityKeyRowType))) 1945if (TypeSemantics.IsEntityType(converted.ResultType)) 1949else if (!TypeSemantics.IsReferenceType(converted.ResultType)) 1951throw EntityUtil.EntitySqlError(keyExpr.ArgExpr.ErrCtx, Strings.InvalidKeyArgument(converted.ResultType.EdmType.FullName)); 1991if (!TypeSemantics.IsNumericType(operands.Left.ResultType)) 1998if (!TypeSemantics.IsNumericType(operands.Right.ResultType)) 2003if (null == TypeHelpers.GetCommonTypeUsage(operands.Left.ResultType, operands.Right.ResultType)) 2006operands.Left.ResultType.EdmType.FullName, operands.Right.ResultType.EdmType.FullName)); 2028if (!TypeSemantics.IsNumericType(operands.Left.ResultType) && !TypeSemantics.IsPrimitiveType(operands.Left.ResultType, PrimitiveTypeKind.String)) 2033if (!TypeSemantics.IsNumericType(operands.Right.ResultType) && !TypeSemantics.IsPrimitiveType(operands.Right.ResultType, PrimitiveTypeKind.String)) 2038if (TypeHelpers.GetCommonTypeUsage(operands.Left.ResultType, operands.Right.ResultType) == null) 2041operands.Left.ResultType.EdmType.FullName, operands.Right.ResultType.EdmType.FullName)); 2074if (!IsBooleanType(leftExpr.ResultType)) 2082if (null != rightExpr && !IsBooleanType(rightExpr.ResultType)) 2111if (!TypeSemantics.IsEqualComparableTo(compArgs.Left.ResultType, compArgs.Right.ResultType)) 2114compArgs.Left.ResultType.EdmType.FullName, compArgs.Right.ResultType.EdmType.FullName)); 2138if (!TypeSemantics.IsOrderComparableTo(compArgs.Left.ResultType, compArgs.Right.ResultType)) 2141compArgs.Left.ResultType.EdmType.FullName, compArgs.Right.ResultType.EdmType.FullName)); 2173if (!TypeSemantics.IsCollectionType(leftExpr.ResultType)) 2186if (!TypeSemantics.IsCollectionType(rightExpr.ResultType)) 2192TypeUsage leftElemType = TypeHelpers.GetElementTypeUsage(leftExpr.ResultType); 2193TypeUsage rightElemType = TypeHelpers.GetElementTypeUsage(rightExpr.ResultType); 2204if (!TypeHelpers.IsSetComparableOpType(TypeHelpers.GetElementTypeUsage(leftExpr.ResultType))) 2210TypeHelpers.GetElementTypeUsage(leftExpr.ResultType).EdmType.FullName)); 2216if (!TypeHelpers.IsSetComparableOpType(TypeHelpers.GetElementTypeUsage(rightExpr.ResultType))) 2222TypeHelpers.GetElementTypeUsage(rightExpr.ResultType).EdmType.FullName)); 2247if (!TypeSemantics.IsCollectionType(leftExpr.ResultType)) 2255if (astBuiltInExpr.Kind == AST.BuiltInKind.Distinct && !TypeHelpers.IsValidDistinctOpType(TypeHelpers.GetElementTypeUsage(leftExpr.ResultType))) 2274if (!TypeSemantics.IsCollectionType(rightExpr.ResultType)) 2285TypeUsage elementType = TypeHelpers.GetElementTypeUsage(rightExpr.ResultType); 2290if (TypeSemantics.IsCollectionType(leftExpr.ResultType)) 2298TypeUsage commonElemType = TypeHelpers.GetCommonTypeUsage(leftExpr.ResultType, TypeHelpers.GetElementTypeUsage(rightExpr.ResultType)); 2301throw EntityUtil.EntitySqlError(astBuiltInExpr.ErrCtx, Strings.InvalidInExprArgs(leftExpr.ResultType.EdmType.FullName, rightExpr.ResultType.EdmType.FullName)); 2561rowColumns.Add(aliasName, colExpr.ResultType); 2583var multisetTypes = mSetExprs.Where(e => e != null).Select(e => e.ResultType).ToArray(); 2639if (!IsBooleanType(whenExpression.ResultType)) 2659var resultTypes = thenExprList.Where(e => e != null).Select(e => e.ResultType).ToList(); 2662resultTypes.Add(elseExpr.ResultType); 2938ValidateDistinctProjection(projectExpression.ResultType, selectClause); 2989if (!TypeSemantics.IsPromotableTo(expr.ResultType, sr.TypeResolver.Int64Type)) 2991throw EntityUtil.EntitySqlError(errCtx, Strings.PlaceholderExpressionMustBeCompatibleWithEdm64(exprName, expr.ResultType.EdmType.FullName)); 3087if (!TypeSemantics.IsCollectionType(converted.ResultType)) 3337if (!IsBooleanType(filterConditionExpr.ResultType)) 3456if (!TypeHelpers.IsValidGroupKeyType(keyExpr.ResultType)) 3615converted = converted.ExpressionKind == CommandTrees.DbExpressionKind.Null ? converted : converted.ResultType.Null(); 3857DbVariableReferenceExpression aggVarRef = groupAggregateInfo.AggregateStubExpression.ResultType.Variable(groupAggregateInfo.AggregateName); 3963Debug.Assert(TypeSemantics.IsCollectionType(lambdaVariable.ResultType)); 3971TypeSemantics.IsRowType(projectExpression.Projection.ResultType)) 3973if (!TypeSemantics.IsEqual(projectExpression.Projection.ResultType, projectExpression.Input.Variable.ResultType)) 3978IBaseList<EdmMember> inputVariableTypeProperties = TypeHelpers.GetAllStructuralMembers(projectExpression.Input.Variable.ResultType); 4009VarRef = varBasedKeyExpr.ResultType.Variable(name); 4142DbVariableReferenceExpression projectionExpressionRef = projectionExpression.Value.ResultType.Variable(projectionExpression.Key); 4183if (!TypeHelpers.IsValidSortOpKeyType(keyExpr.ResultType)) 4199if (!IsStringType(keyExpr.ResultType)) 4201throw EntityUtil.EntitySqlError(orderClauseItem.OrderExpr.ErrCtx, Strings.InvalidKeyTypeForCollation(keyExpr.ResultType.EdmType.FullName)); 4387if (TypeSemantics.IsNumericType(args.Left.ResultType)) 4403argTypes.Add(args.Left.ResultType); 4404argTypes.Add(args.Right.ResultType); 4479if (TypeSemantics.IsUnsignedNumericType(argument.ResultType)) 4482if (!TypeHelpers.TryGetClosestPromotableType(argument.ResultType, out closestPromotableType)) 4484throw EntityUtil.EntitySqlError(Strings.InvalidUnsignedTypeForUnaryMinusOperation(argument.ResultType.EdmType.FullName)); 4726if (!TypeSemantics.IsCollectionType(elemExpr.ResultType)) 4731if (!TypeSemantics.IsCollectionType(TypeHelpers.GetElementTypeUsage(elemExpr.ResultType))) 4847if (isNullExpr != null && !TypeHelpers.IsValidIsNullOpType(isNullExpr.ResultType)) 4867if (isNullExpr != null && !TypeHelpers.IsValidIsNullOpType(isNullExpr.ResultType)) 4893if (!isNominalTypeAllowed && !TypeSemantics.IsEntityType(exprToFilter.ResultType)) 4897exprToFilter.ResultType.EdmType.BuiltInTypeKind.ToString(), 4898exprToFilter.ResultType.EdmType.FullName)); 4900else if (isNominalTypeAllowed && !TypeSemantics.IsNominalType(exprToFilter.ResultType)) 4904exprToFilter.ResultType.EdmType.BuiltInTypeKind.ToString(), 4905exprToFilter.ResultType.EdmType.FullName)); 4921if (!TypeSemantics.IsPolymorphicType(exprToFilter.ResultType)) 4931if (!IsSubOrSuperType(exprToFilter.ResultType, typeToFilterTo)) 4933throw EntityUtil.EntitySqlError(bltInExpr.ErrCtx, Strings.NotASuperOrSubType(exprToFilter.ResultType.EdmType.FullName, 4988else if (!isNominalTypeAllowed && !TypeSemantics.IsEntityType(exprToTreat.ResultType)) 4992exprToTreat.ResultType.EdmType.BuiltInTypeKind.ToString(), 4993exprToTreat.ResultType.EdmType.FullName)); 4995else if (isNominalTypeAllowed && !TypeSemantics.IsNominalType(exprToTreat.ResultType)) 4999exprToTreat.ResultType.EdmType.BuiltInTypeKind.ToString(), 5000exprToTreat.ResultType.EdmType.FullName)); 5003if (!TypeSemantics.IsPolymorphicType(exprToTreat.ResultType)) 5013if (!IsSubOrSuperType(exprToTreat.ResultType, typeToTreatTo)) 5015throw EntityUtil.EntitySqlError(bltInExpr.Arg1.ErrCtx, Strings.NotASuperOrSubType(exprToTreat.ResultType.EdmType.FullName, 5048if (!TypeSemantics.IsScalarType(exprToCast.ResultType)) 5053if (!TypeSemantics.IsCastAllowed(exprToCast.ResultType, typeToCastTo)) 5055throw EntityUtil.EntitySqlError(bltInExpr.Arg1.ErrCtx, Strings.InvalidCast(exprToCast.ResultType.EdmType.FullName, typeToCastTo.EdmType.FullName)); 5075if (!TypeSemantics.IsCollectionType(exprToFilter.ResultType)) 5080TypeUsage elementType = TypeHelpers.GetElementTypeUsage(exprToFilter.ResultType); 5140else if (!IsStringType(matchExpr.ResultType)) 5150else if (!IsStringType(patternExpr.ResultType)) 5162else if (!IsStringType(escapeExpr.ResultType)) 5216TypeUsage rangeCommonType = TypeHelpers.GetCommonTypeUsage(limitsExpr.Left.ResultType, limitsExpr.Right.ResultType); 5219throw EntityUtil.EntitySqlError(bltInExpr.Arg1.ErrCtx, Strings.BetweenLimitsTypesAreNotCompatible(limitsExpr.Left.ResultType.EdmType.FullName, limitsExpr.Right.ResultType.EdmType.FullName)); 5225if (!TypeSemantics.IsOrderComparableTo(limitsExpr.Left.ResultType, limitsExpr.Right.ResultType)) 5227throw EntityUtil.EntitySqlError(bltInExpr.Arg1.ErrCtx, Strings.BetweenLimitsTypesAreNotOrderComparable(limitsExpr.Left.ResultType.EdmType.FullName, limitsExpr.Right.ResultType.EdmType.FullName)); 5242if (!TypeSemantics.IsOrderComparableTo(valueExpr.ResultType, rangeCommonType)) 5244throw EntityUtil.EntitySqlError(bltInExpr.Arg1.ErrCtx, Strings.BetweenValueIsNotOrderComparable(valueExpr.ResultType.EdmType.FullName, rangeCommonType.EdmType.FullName));

188Debug.Assert(paramDef.ResultType.IsReadOnly, "paramDef.ResultType.IsReadOnly must be set"); 215Debug.Assert(varDef.ResultType.IsReadOnly, "varDef.ResultType.IsReadOnly must be set"); 600if (TypeSemantics.IsCollectionType(valueExpr.ResultType)) 602throw EntityUtil.EntitySqlError(errCtx, Strings.NotAMemberOfCollection(name, valueExpr.ResultType.EdmType.FullName)); 606throw EntityUtil.EntitySqlError(errCtx, Strings.NotAMemberOfType(name, valueExpr.ResultType.EdmType.FullName)); 619if (Helper.IsStructuralType(valueExpr.ResultType.EdmType)) 622if (TypeResolver.Perspective.TryGetMember((StructuralType)valueExpr.ResultType.EdmType, name, _parserOptions.NameComparisonCaseInsensitive /*ignoreCase*/, out member)) 643if (TypeSemantics.IsReferenceType(valueExpr.ResultType)) 646TypeUsage derefExprType = derefExpr.ResultType; 654throw EntityUtil.EntitySqlError(errCtx, Strings.InvalidDeRefProperty(name, derefExprType.EdmType.FullName, valueExpr.ResultType.EdmType.FullName)); 1483base.AttachToAstNode(aggregateName, aggregateDefinition.ResultType);

287overload.Parameters.Select(p => p.ResultType).SequenceEqual(functionInfo.Parameters.Select(p => p.ResultType), TypeUsageStructuralComparer.Instance)))

162Debug.Assert(TypeSemantics.IsPromotableTo(argumentNode.Op.Type, commandParam.ResultType), "Argument type must be promotable to parameter type."); 229TypeSemantics.IsPromotableTo(queryExpression.ResultType, this.FunctionImport.ReturnParameter.TypeUsage), 236TypeSemantics.IsEqual(queryExpression.ResultType, this.FunctionImport.ReturnParameter.TypeUsage), 403return columnRef.Equal(columnRef.ResultType.Constant(condition.Value)); 417if (!TypeSemantics.IsEqual(accessorExpr.ResultType, edmProperty.TypeUsage)) 426Debug.Assert(row.ResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.RowType, "Input type is expected to be a row type."); 427var rowType = (RowType)row.ResultType.EdmType; 444Debug.Assert(TypeSemantics.IsCollectionType(queryExpression.ResultType), "Store function must be TVF (collection expected)."); 445var collectionType = (CollectionType)queryExpression.ResultType.EdmType;

116TypeUsage nodeType = node.ResultType;

474TypeUsage nodeType = node.ResultType; 500TypeUsage nodeType = node.ResultType;

84if (project.Projection.ResultType.EdmType.BuiltInTypeKind != BuiltInTypeKind.EntityType) { return false; } 195entityType = (EntityType)constructor.ResultType.EdmType; 272if (!newX.ResultType.EdmType.EdmEquals(newY.ResultType.EdmType)) { return false; }

115CollectionType queryResultType = (commandTree.Query.ResultType.EdmType) as CollectionType;

342Debug.Assert(typeConstructor != null && typeConstructor.ResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.EntityType, 345(EntityType)typeConstructor.ResultType.EdmType,

72parameters.Select(pInfo => pInfo.ResultType.Variable(pInfo.ParameterName)));

143EdmType type = expression.ResultType.EdmType; 367StructuralType structuralType = (expression.ResultType.EdmType as StructuralType); 379if (expression.ResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.AssociationType)

472if (!TypeSemantics.IsStructurallyEqual(function.ReturnParameter.TypeUsage, generatedDefinition.Body.ResultType)) 474throw EntityUtil.FunctionDefinitionResultTypeMismatch(function, generatedDefinition.Body.ResultType);

69AssertEdmType(queryCommandTree.Query.ResultType);

89return converter.Convert().ResultType;

738return DbExpressionBuilder.Null(expression.ResultType); 743return DbExpressionBuilder.Constant(expression.ResultType, objParam.Value); 759if (null == GetCastTargetType(setSource.ResultType, toClrType, fromClrType, true)) 766TypeUsage toType = GetCastTargetType(source.ResultType, toClrType, fromClrType, true); 860if (InitializerMetadata.TryGetInitializerMetadata(input.ResultType, out initializerMetadata)) 931TypeUsage toType = GetCastTargetType(cqt.ResultType, toClrType, fromClrType, false); 1170VerifyTypeSupportedForComparison(operandClrType, operand.ResultType, null); 1180VerifyTypeSupportedForComparison(leftClrType, left.ResultType, null); 1181VerifyTypeSupportedForComparison(rightClrType, right.ResultType, null); 1184TypeUsage leftType = left.ResultType; 1185TypeUsage rightType = right.ResultType; 1191RefType leftRefType = left.ResultType.EdmType as RefType; 1192RefType rightRefType = right.ResultType.EdmType as RefType; 1202RowType leftType = left.ResultType.EdmType as RowType; 1203RowType rightType = left.ResultType.EdmType as RowType; 1383translatedPatternExpression = DbExpressionBuilder.Constant(constantExpression.ResultType, preparedValue); 1475translatedArgumentTypes.Add(translatedArgument.ResultType); 1580properties.Add(new EdmProperty(column.Key, column.Value.ResultType));

607var argumentTypes = arguments.Select(a => a.ResultType).ToList(); 619return ValidateReturnType(result, result.ResultType, parent, call, call.Type, false); 634BuiltInTypeKind type = argumentExpr.ResultType.EdmType.BuiltInTypeKind; 651RowType rowType = argumentExpr.ResultType.EdmType as RowType; 893TypeUsage updatedType = argument.ResultType.ShallowCopy(new FacetValues { Unicode = _isUnicode }); 1194!TypeSemantics.IsPrimitiveType(argument.ResultType, PrimitiveTypeKind.Int32)) 1606if (!TypeSemantics.IsEqualComparable(outerKeySelector.ResultType) || 1607!TypeSemantics.IsEqualComparable(innerKeySelector.ResultType)) 1799if (!TypeUsageEquals(returnType, ((CollectionType)operand.ResultType.EdmType).TypeUsage)) 1812if (!TypeUsageEquals(returnType, operand.ResultType)) 1989if (!TypeUsageEquals(constantExpression.ResultType, returnType)) 2047if (TypeSemantics.IsCollectionType(operand.ResultType)) 2054call.Method.Name, operand.ResultType.EdmType.Name)); 2332Debug.Assert(TypeSemantics.IsScalarType(element.ResultType), "Primitive or enum type expected at this point."); 2339thenExpressions.Add(DbExpressionBuilder.Constant(element.ResultType, defaultValue)); 2559RowType applyRowType = (RowType)(applyBinding.Variable.ResultType.EdmType); 2752if (!TypeSemantics.IsEqualComparable(keySelector.ResultType)) 2789properties.Add(new EdmProperty(KeyColumnName, projectionTerms[0].ResultType)); 2790properties.Add(new EdmProperty(GroupColumnName, projectionTerms[1].ResultType)); 2874if (!TypeSemantics.IsEqualComparable(outerSelector.ResultType) || 2875!TypeSemantics.IsEqualComparable(innerSelector.ResultType)) 2929project.Projection.ResultType.EdmType.BuiltInTypeKind != BuiltInTypeKind.RowType) 2934var outerRowType = (RowType)projection.ResultType.EdmType; 2959innerProject.Projection.ResultType.EdmType.BuiltInTypeKind != BuiltInTypeKind.RowType) 2964var innerRowType = (RowType)innerProjection.ResultType.EdmType; 2973var newProjection = projection.ResultType.New(newProjectionArguments);

247return left.ResultType.Constant(combineConstants((int)leftValue, (int)rightValue));

174instance.ResultType, instance, out propertyExpression)) 340InitializerMetadata.TryGetInitializerMetadata(property.Instance.ResultType, out initializerMetadata) && 362if (BuiltInTypeKind.CollectionType == propertyExpression.ResultType.EdmType.BuiltInTypeKind) 667Debug.Assert(!TypeSemantics.IsCollectionType(argument.ResultType), "Did not expect collection type"); 687Debug.Assert(!TypeSemantics.IsCollectionType(argument.ResultType), "Did not expect collection type"); 1082TypeUsage fromType = operand.ResultType; 1096if (TypeSemantics.IsPrimitiveType(left.ResultType, PrimitiveTypeKind.String) && 1097TypeSemantics.IsPrimitiveType(right.ResultType, PrimitiveTypeKind.String)) 1182if (TypeSemantics.IsBooleanType(left.ResultType)) 1230if (TypeSemantics.IsBooleanType(operand.ResultType)) 1280TypeUsage fromType = operand.ResultType;

128return query.ResultType;

62if (!TryGetEntityType(this.Query.ResultType, out entityType))

53TypeUsage treeResultType = tree.Query.ResultType;

74Debug.Assert(rewriter.SpanIndex != null || tree.Query.ResultType.EdmEquals(newQuery.ResultType), "Query was rewritten for Span but no SpanIndex was created?"); 177switch(expression.ResultType.EdmType.BuiltInTypeKind) 180return RewriteEntity(expression, (EntityType)expression.ResultType.EdmType); 183return RewriteCollection(expression, (CollectionType)expression.ResultType.EdmType); 186return RewriteRow(expression, (RowType)expression.ResultType.EdmType); 307RowType spanRowType = (RowType)spannedExpression.ResultType.EdmType; 419properties.Add(new EdmProperty(columnProp.Name, columnDef.ResultType)); 446AddSpannedRowType(rewrittenRow, expression.ResultType); 742Debug.Assert(TypeSemantics.IsCollectionType(expression.ResultType), "Non-collection input to projection?"); 746TypeUsage elementType = ((CollectionType)expression.ResultType.EdmType).TypeUsage; 805DbVariableReferenceExpression sourceRef = new DbVariableReferenceExpression(expression.NavigationSource.ResultType, varName);

221PlanCompiler.Assert(TypeSemantics.IsCollectionType(publisher.ResultType), "non-collection type used as RelOpInfo publisher"); 1332PlanCompiler.Assert(expr.ResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.CollectionType, 1491PlanCompiler.Assert(TypeSemantics.IsPrimitiveType(predicateExpr.ResultType, PrimitiveTypeKind.Boolean), "Invalid FilterOp Predicate (non-ScalarOp or non-Boolean result)"); 2156CollectionType outputType = TypeHelpers.GetEdmType<CollectionType>(TypeHelpers.GetCommonTypeUsage(left.ResultType, right.ResultType));

361if (TypeSemantics.IsPrimitiveType(expr.ResultType, PrimitiveTypeKind.Boolean)) 485node = ConvertRelOpToScalarOpTree(node, expr.ResultType); 988ConstantBaseOp op = _iqtCommand.CreateConstantOp(e.ResultType, e.GetValue()); 994NullOp op = _iqtCommand.CreateNullOp(e.ResultType); 1213Helper.IsEntityType(propertyExpression.Instance.ResultType.EdmType)) 1215EntityType instanceType = (EntityType)propertyExpression.Instance.ResultType.EdmType; 1266Helper.IsStructuralType(e.Instance.ResultType.EdmType)) 1271System.Collections.IList propertyOrEndMembers = Helper.GetAllStructuralMembers(e.Instance.ResultType.EdmType); 1293retNode = BuildSoftCast(retNode, e.ResultType); 1315TypeUsage commonType = TypeHelpers.GetCommonTypeUsage(e.Left.ResultType, e.Right.ResultType); 1318if (!Command.EqualTypes(e.Left.ResultType, e.Right.ResultType)) 1497if (TypeSemantics.IsEntityType(e.Argument.ResultType)) 1499argNode = BuildEntityRef(argNode, e.Argument.ResultType); 1507Op op = _iqtCommand.CreateArithmeticOp(s_opMap[e.ExpressionKind], e.ResultType); 1514children.Add(BuildSoftCast(child, e.ResultType)); 1549Op elementOp = _iqtCommand.CreateElementOp(e.ResultType); 1553inputSetNode = BuildSoftCast(inputSetNode, TypeHelpers.CreateCollectionTypeUsage(e.ResultType)); 1596PlanCompiler.Assert(TypeSemantics.IsCollectionType(expression.ResultType), "SetOp DbExpression does not have collection result type?"); 1606leftNode = BuildSoftCast(leftNode, expression.ResultType); 1607rightNode = BuildSoftCast(rightNode, expression.ResultType); 1610Var outputVar = _iqtCommand.CreateSetOpVar(TypeHelpers.GetEdmType<CollectionType>(expression.ResultType).TypeUsage); 1666op = _iqtCommand.CreateFakeTreatOp(e.ResultType); 1670op = _iqtCommand.CreateTreatOp(e.ResultType); 1691Op op = _iqtCommand.CreateCastOp(e.ResultType); 1702childNodes.Add(BuildSoftCast(VisitExprAsScalar(e.Then[idx]), e.ResultType)); 1706childNodes.Add(BuildSoftCast(VisitExprAsScalar(e.Else), e.ResultType)); 1707return _iqtCommand.CreateNode(_iqtCommand.CreateCaseOp(e.ResultType), childNodes); 2004PlanCompiler.Assert(TypeSemantics.IsCollectionType(e.Argument.ResultType), "Non-Collection Type Argument in DbOfTypeExpression"); 2037if (TypeSemantics.IsCollectionType(e.ResultType)) 2039newInstOp = _iqtCommand.CreateNewMultisetOp(e.ResultType); 2041else if (TypeSemantics.IsRowType(e.ResultType)) 2043newInstOp = _iqtCommand.CreateNewRecordOp(e.ResultType); 2045else if (TypeSemantics.IsEntityType(e.ResultType)) 2059newInstOp = _iqtCommand.CreateNewEntityOp(e.ResultType, relPropertyList); 2063newInstOp = _iqtCommand.CreateNewInstanceOp(e.ResultType); 2071if (TypeSemantics.IsStructuralType(e.ResultType)) 2073StructuralType resultType = TypeHelpers.GetEdmType<StructuralType>(e.ResultType); 2084CollectionType resultType = TypeHelpers.GetEdmType<CollectionType>(e.ResultType); 2110Op op = _iqtCommand.CreateRefOp(e.EntitySet, e.ResultType); 2118Op op = _iqtCommand.CreateNavigateOp(e.ResultType, relProperty); 2125Op op = _iqtCommand.CreateDerefOp(e.ResultType); 2131Op op = _iqtCommand.CreateGetRefKeyOp(e.ResultType); 2137Op op = _iqtCommand.CreateGetEntityRefOp(e.ResultType); 2213DiscriminatedNewEntityOp newInstOp = _iqtCommand.CreateDiscriminatedNewEntityOp(e.Projection.ResultType, 2380ExtractElementRowType(e.ResultType), 2438ExtractElementRowType(e.ResultType), 2522groupAggDefNode = ProcessGroupAggregate(keyVarDefNodes, copyOfInput, copyOfKeyVarDefNodes, copyKeyVarSet, e.Input.Expression.ResultType, out aggVar); 2576ExtractElementRowType(e.ResultType),

66md.CollectionType collType = TypeHelpers.GetEdmType<md.CollectionType>(cqtree.Query.ResultType);

563SqlParameter parameter = CreateParameter(expression.Value, expression.ResultType);

300IList<EdmProperty> properties = TypeHelpers.GetProperties(input.ResultType); 462RowType rowExprType = (RowType)rowExpr.ResultType.EdmType;

449string functionNameWithSrid = (TypeSemantics.IsPrimitiveType(functionExpression.ResultType, PrimitiveTypeKind.Geometry) ? "geometry::STGeomFromText" : "geography::STGeomFromText"); 450string functionNameWithoutSrid = (TypeSemantics.IsPrimitiveType(functionExpression.ResultType, PrimitiveTypeKind.Geometry) ? "geometry::Parse" : "geography::Parse"); 466return HandleSpatialStaticMethodFunctionAppendSrid(sqlgen, functionExpression, (TypeSemantics.IsPrimitiveType(functionExpression.ResultType, PrimitiveTypeKind.Geometry) ? "geometry::GeomFromGml" : "geography::GeomFromGml")); 471return HandleSpatialStaticMethodFunctionAppendSrid(sqlgen, functionExpression, (TypeSemantics.IsPrimitiveType(functionExpression.ResultType, PrimitiveTypeKind.Geometry) ? "geometry::STGeomFromWKB" : "geography::STGeomFromWKB")); 485DbExpression sridExpression = (TypeSemantics.IsPrimitiveType(functionExpression.ResultType, PrimitiveTypeKind.Geometry) ? defaultGeometrySridExpression : defaultGeographySridExpression); 553if (Helper.IsSpatialType(e.ResultType, out spatialTypeKind)) 1221bool isPrimitiveType = TypeHelpers.TryGetPrimitiveTypeKind(e.Arguments[0].ResultType, out typeKind); 1448if (TypeSemantics.IsPrimitiveType(e.Arguments[0].ResultType, PrimitiveTypeKind.Byte)) 1527DbConstantExpression escapedSearchParamExpression = new DbConstantExpression(constSearchParamExpression.ResultType, searchParamBuilder.ToString()); 1770TypeUsage storeType = sqlgen.StoreItemCollection.StoreProviderManifest.GetStoreType(e.Arguments[i].ResultType); 1818if (TypeSemantics.IsPrimitiveType(e.Arguments[i].ResultType, type))

522if (TypeSemantics.IsCollectionType(targetTree.Query.ResultType)) 701if (Helper.IsSpatialType(e.ResultType)) 711result.Append(GetSqlPrimitiveType(e.ResultType)); 728if (TypeSemantics.IsPrimitiveType(e.Left.ResultType, PrimitiveTypeKind.String)) 870(TypeHelpers.TryGetIsUnicode(argument.ResultType, out isUnicode)) && 883TypeUsage type = argument.ResultType; 908TypeUsage resultType = e.ResultType; 948result.Append(e.ResultType.EdmType.Name); 957result.Append(e.ResultType.EdmType.Name); 1017if (!TypeHelpers.TryGetIsUnicode(e.ResultType, out isUnicode)) 1184TypeUsage inputType = TypeHelpers.GetElementTypeUsage(e.Argument.ResultType); 1438RowType groupByType = TypeHelpers.GetEdmType<RowType>(TypeHelpers.GetEdmType<CollectionType>(e.ResultType).TypeUsage); 1700TypeUsage inputType = TypeHelpers.GetElementTypeUsage(e.Argument.ResultType); 1761if (TypeSemantics.IsCollectionType(e.ResultType)) 1808if (TypeSemantics.IsPrimitiveType(comparisonExpression.Left.ResultType, PrimitiveTypeKind.String)) 1836TypeUsage type = e.ResultType; 1931if (TypeSemantics.IsPrimitiveType(key.ResultType, PrimitiveTypeKind.String)) 1944HandleInValue(sqlBuilder, value, key.ResultType.EdmType == value.ResultType.EdmType, forceNonUnicodeOnQualifyingValues); 1964HandleInValue(sqlBuilder, value, key.ResultType.EdmType == value.ResultType.EdmType, forceNonUnicodeOnQualifyingValues); 2078return first.ResultType == second.ResultType && this.Equals(first.Argument, second.Argument); 2804bool isCastOptional = left.ResultType.EdmType == right.ResultType.EdmType; 2923TypeUsage inputType = TypeHelpers.GetElementTypeUsage(elementExpr.Argument.ResultType); 2934CollectionType collectionType = TypeHelpers.GetEdmType<CollectionType>(e.ResultType); 3260RowType rowType = e.ResultType.EdmType as RowType; 3271if (TypeSemantics.IsRowType(argument.ResultType)) 3352Symbol fromSymbol = new Symbol("X", TypeHelpers.GetElementTypeUsage(left.ResultType), leftSelectStatement.OutputColumns, true); 4080Debug.Assert(TypeSemantics.IsCollectionType(e.ResultType)); 4108type = TypeHelpers.GetElementTypeUsage(e.ResultType); 4112Debug.Assert(TypeSemantics.IsCollectionType(e.ResultType)); 4113type = TypeHelpers.GetEdmType<CollectionType>(e.ResultType).TypeUsage;