public static SignaturePart Adecl([NotNull] SignaturePart left, [NotNull] SignaturePart right, [CanBeNull] string name = null)
{
return(new AdeclPart(left, right)
{
Name = name
});
}
public static SignaturePart From([NotNull] SignaturePart inner)
{
if (inner is AlternativesPart ap)
{
return(AlternativesPart.From(ap.Alternatives.Select(From)));
}
return(new QuotedPart(inner));
}
public static SignaturePart From([NotNull] SignaturePart inner)
{
switch (inner)
{
case VarArgsPart _:
case OptionalPart _:
return(inner);
default:
return(new OptionalPart(inner));
}
}
public static SignaturePart From([NotNull] SignaturePart inner, bool isRequired)
{
switch (inner)
{
case VarArgsPart vp:
inner = vp.Inner;
break;
case OptionalPart op:
inner = op.Inner;
break;
}
return(new VarArgsPart(inner, isRequired));
}
static SignaturePart ConstrainByType([NotNull] SignaturePart part, [NotNull] Type elementType)
{
System.Diagnostics.Debug.Assert(!elementType.IsArray);
// treat Nullable<Foo> as an optional Foo
bool isOptional = false;
var nullableUnderlyingType = Nullable.GetUnderlyingType(elementType);
if (nullableUnderlyingType != null)
{
isOptional = true;
elementType = nullableUnderlyingType;
}
// treat LocalEnvironment as an optional ZilEnvironment
if (elementType == typeof(LocalEnvironment))
{
isOptional = true;
elementType = typeof(ZilEnvironment);
}
// find an appropriate type or primtype constraint for the element type
if (!StandardTypeConstraints.TryGetValue(elementType, out var constraint))
{
BuiltinPrimTypeAttribute primTypeAttr;
if ((primTypeAttr = elementType.GetCustomAttribute <BuiltinPrimTypeAttribute>(false)) != null)
{
constraint = Constraint.OfPrimType(primTypeAttr.PrimType);
}
else
{
BuiltinTypeAttribute typeAttr;
if ((typeAttr = elementType.GetCustomAttribute <BuiltinTypeAttribute>(false)) != null)
{
constraint = Constraint.OfType(typeAttr.Name);
}
else
{
throw new UnhandledCaseException(elementType.Name);
}
}
}
part = SignatureBuilder.Constrained(part, constraint);
return(isOptional ? SignatureBuilder.Optional(part) : part);
}
static SignaturePart ApplyParamAttributes([NotNull] SignaturePart part, [NotNull] ParameterInfo pi)
{
// TODO: also handle VariableAttribute?
if (pi.IsDefined(typeof(TableAttribute), false))
{
part = SignatureBuilder.Constrained(part, Constraint.OfPrimType(PrimType.TABLE));
}
if (pi.IsDefined(typeof(ObjectAttribute), false))
{
part = SignatureBuilder.Constrained(part, Constraint.OfType(StdAtom.OBJECT));
}
if (pi.IsOptional)
{
part = SignatureBuilder.Optional(part);
}
return(part);
}
VarArgsPart([NotNull] SignaturePart inner, bool isRequired)
{
Inner = inner;
Required = isRequired;
}
public static SignaturePart Optional([NotNull] SignaturePart inner)
{
return(OptionalPart.From(inner));
}
public static SignaturePart From([NotNull] SignaturePart inner, [NotNull] Constraint constraint)
{
var newConstraint = inner.Constraint.And(constraint);
return(new ConstrainedPart(inner is ConstrainedPart icp ? icp.Inner : inner, newConstraint));
}
static SignaturePart ConvertForSubr(
[NotNull] Type paramType,
[NotNull] string name,
// ReSharper disable once SuggestBaseTypeForParameter
[NotNull][ItemNotNull] object[] attrs,
bool isOptional,
// ReSharper disable once UnusedParameter.Local
object defaultValue)
{
// [Either], [Required], and [Decl] go on the parameter
var isRequired = attrs.OfType <RequiredAttribute>().Any();
if (isRequired && isOptional)
{
throw new InvalidOperationException("A parameter can't be both required and optional");
}
var eitherAttr = attrs.OfType <EitherAttribute>().SingleOrDefault();
var declAttr = attrs.OfType <DeclAttribute>().SingleOrDefault();
// [ZilStructuredParam] and [ZilSequenceParam] go on the element type
var(isArray, elementType) = CheckArray(paramType);
var structAttr = elementType.GetCustomAttribute <ZilStructuredParamAttribute>(false);
var seqAttr = elementType.GetCustomAttribute <ZilSequenceParamAttribute>(false);
int attrCount =
(eitherAttr != null ? 1 : 0) +
(declAttr != null ? 1 : 0) +
(structAttr != null ? 1 : 0) +
(seqAttr != null ? 1 : 0);
if (attrCount > 1)
{
throw new InvalidOperationException(
nameof(EitherAttribute) + ", " +
nameof(DeclAttribute) + ", " +
nameof(ZilStructuredParamAttribute) + ", or " +
nameof(ZilSequenceParamAttribute) + ": pick at most one");
}
SignaturePart elemPart = null;
if (eitherAttr != null)
{
elemPart = ConvertEither(eitherAttr.Types, eitherAttr.DefaultParamDesc ?? name);
}
else if (declAttr != null)
{
elemPart = SignatureBuilder.MaybeConvertDecl(declAttr);
}
else if (structAttr != null)
{
elemPart = ConvertStruct(elementType, structAttr, name);
}
else if (seqAttr != null)
{
elemPart = ConvertSequence(elementType, name);
}
if (elemPart == null)
{
elemPart = SignatureBuilder.Identifier(name);
if (elementType != typeof(ZilObject))
{
elemPart = ConstrainByType(elemPart, elementType);
}
}
if (isArray)
{
elemPart = SignatureBuilder.VarArgs(elemPart, isRequired);
}
if (isOptional)
{
//XXX use defaultValue somehow?
elemPart = SignatureBuilder.Optional(elemPart);
}
return(elemPart);
}
OptionalPart([NotNull] SignaturePart inner)
{
Inner = inner;
}
static IEnumerable <SignaturePart> ExpandAlternatives(SignaturePart p)
{
return(p is AlternativesPart ap ? ap.Alternatives : Enumerable.Repeat(p, 1));
}
public AdeclPart([NotNull] SignaturePart left, [NotNull] SignaturePart right)
{
Left = left;
Right = right;
}
public static IEnumerable <SignaturePart> ExpandSequenceParts(SignaturePart p)
{
return(p is SequencePart sp ? sp.Parts : Enumerable.Repeat(p, 1));
}
QuotedPart([NotNull] SignaturePart inner)
{
Inner = inner;
}
ConstrainedPart([NotNull] SignaturePart inner, [NotNull] Constraint constraint)
{
Inner = inner;
Constraint = constraint;
}
public static SignaturePart VarArgs([NotNull] SignaturePart inner, bool isRequired)
{
return(VarArgsPart.From(inner, isRequired));
}
public static SignaturePart Quote([NotNull] SignaturePart second)
{
return(QuotedPart.From(second));
}
public static SignaturePart Constrained([NotNull] SignaturePart inner, [NotNull] Constraint constraint)
{
return(ConstrainedPart.From(inner, constraint));
}
