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)); }