public IfErrorFunction()
: base("IfError", TexlStrings.AboutIfError, FunctionCategories.Logical, DType.Unknown, 0, 2, int.MaxValue)
{
ScopeInfo = new FunctionScopeInfo(this,
iteratesOverScope: false,
scopeType: DType.CreateRecord(
new TypedName(ErrorType.ReifiedError(), new DName("FirstError")),
new TypedName(ErrorType.ReifiedErrorTable(), new DName("AllErrors")),
new TypedName(DType.ObjNull, new DName("ErrorResult"))),
appliesToArgument: (i => i > 0 && (i % 2 == 1)));
}
// Get the correct derived type
internal static FormulaType Build(DType type)
{
switch (type.Kind)
{
case DKind.ObjNull: return(Blank);
case DKind.Record: return(new RecordType(type));
case DKind.Table: return(new TableType(type));
case DKind.Number: return(Number);
case DKind.String: return(String);
case DKind.Boolean: return(Boolean);
case DKind.Currency: return(Number); // TODO: validate
case DKind.Time: return(Time);
case DKind.Date: return(Date);
case DKind.DateTime: return(DateTime);
case DKind.DateTimeNoTimeZone: return(DateTimeNoTimeZone);
case DKind.OptionSetValue:
var isBoolean = type.OptionSetInfo?.IsBooleanValued;
return(isBoolean.HasValue && isBoolean.Value ? Boolean : OptionSetValue);
// This isn't quite right, but once we're in the IR, an option set acts more like a record with optionsetvalue fields.
case DKind.OptionSet:
return(new RecordType(DType.CreateRecord(type.GetAllNames(DPath.Root))));
default:
throw new NotImplementedException($"Not implemented type: {type}");
}
}
public override bool CheckInvocation(TexlNode[] args, DType[] argTypes, IErrorContainer errors, out DType returnType, out Dictionary <TexlNode, DType> nodeToCoercedTypeMap)
{
Contracts.AssertValue(args);
Contracts.AssertAllValues(args);
Contracts.AssertValue(argTypes);
Contracts.Assert(args.Length == argTypes.Length);
Contracts.Assert(args.Length == 1);
Contracts.AssertValue(errors);
var reifiedError = ErrorType.ReifiedError();
var acceptedFields = reifiedError.GetNames(DPath.Root);
var requiredKindField = acceptedFields.Where(tn => tn.Name == "Kind").First();
Contracts.Assert(requiredKindField.Type.IsEnum);
var optionalFields = acceptedFields.Where(tn => tn.Name != "Kind");
returnType = DType.ObjNull;
nodeToCoercedTypeMap = null;
var argument = args[0];
var argumentType = argTypes[0];
if (argumentType.Kind != DKind.Record && argumentType.Kind != DKind.Table)
{
errors.EnsureError(argument, TexlStrings.ErrBadType);
return(false);
}
// We cache the whole name list regardless of path.
var names = argumentType.GetNames(DPath.Root).ToArray();
// First handle required fields (currently only 'Kind')
if (!names.Any(field => field.Name == requiredKindField.Name))
{
// Kind is required, point it out to the maker, and specify the enumeration type.
errors.EnsureError(
argument,
TexlStrings.ErrBadSchema_ExpectedType,
reifiedError.GetKindString());
errors.Error(
argument,
TexlStrings.ErrColumnMissing_ColName_ExpectedType,
requiredKindField.Name.Value,
"ErrorKind");
return(false);
}
var argumentKindType = names.First(tn => tn.Name == requiredKindField.Name).Type;
if (!argumentKindType.CoercesTo(requiredKindField.Type))
{
errors.EnsureError(
argument,
TexlStrings.ErrBadSchema_ExpectedType,
reifiedError.GetKindString());
errors.Error(
argument,
TexlStrings.ErrBadRecordFieldType_FieldName_ExpectedType,
requiredKindField.Name.Value,
"ErrorKind");
return(false);
}
bool valid = true;
var record = argument.AsRecord();
foreach (var name in names)
{
if (!acceptedFields.Any(field => field.Name == name.Name))
{
// If they have a record literal, we can position the errors for rejected fields.
if (record != null)
{
errors.EnsureError(record.Children.Where((_, i) => record.Ids[i].Name == name.Name).FirstOrDefault() ?? record, TexlStrings.ErrErrorIrrelevantField);
}
else
{
errors.EnsureError(argument, TexlStrings.ErrErrorIrrelevantField);
}
valid = false;
}
}
bool matchedWithCoercion;
bool typeValid;
if (argumentType.Kind == DKind.Record)
{
// A record with the proper types for the fields that are specified.
var expectedOptionalFieldsRecord = DType.CreateRecord(
acceptedFields.Where(field =>
// Kind has already been handled before
field.Name != "Kind" && names.Any(name => name.Name == field.Name)));
typeValid = CheckType(argument, argumentType, expectedOptionalFieldsRecord, errors, true, out matchedWithCoercion);
}
else
{
// A table with the proper types for the fields that are specified.
var expectedOptionalFieldsTable = DType.CreateTable(
acceptedFields.Where(field =>
// Kind has already been handled before
field.Name != "Kind" && names.Any(name => name.Name == field.Name)));
typeValid = CheckType(argument, argumentType, expectedOptionalFieldsTable, errors, true, out matchedWithCoercion);
}
if (!typeValid)
{
errors.EnsureError(DocumentErrorSeverity.Severe, argument, TexlStrings.ErrTypeError);
valid = false;
}
else if (matchedWithCoercion && valid)
{
var recordOrTableSchema = acceptedFields.Where(field => names.Any(name => name.Name == field.Name));
var expectedRecordOrTable = argumentType.Kind == DKind.Record ?
DType.CreateRecord(recordOrTableSchema) :
DType.CreateTable(recordOrTableSchema);
CollectionUtils.Add(ref nodeToCoercedTypeMap, argument, expectedRecordOrTable);
}
return(valid);
}
/// <returns> /// The <see cref="DType"/> of an error value /// </returns> public static DType ReifiedError() => DType.CreateRecord(ReifiedErrorSchema);
