/// <summary> /// Creates a closured method in the current scope's closure type using function argument records. /// </summary> public MethodEntity CreateClosureMethod(Context ctx, IEnumerable<FunctionArgument> args, TypeSignature returnType = null) { return createClosureMethodInternal(ctx, name => ClosureType.CreateMethod(name, returnType ?? "Unit", args)); }
/// <summary> /// type = namespace [ type_args ] { "[]" | "?" | "~" } /// </summary> private TypeSignature parseType() { var node = attempt(parseNamespace); if (node == null) return null; var args = attempt(parseTypeArgs); if(args != null) node = new TypeSignature(node.Name, args.ToArray()); while (true) { if(check(LexemType.ArrayDef)) node = new TypeSignature(null, "[]", node); else if(check(LexemType.Tilde)) node = new TypeSignature(null, "~", node); else if(check(LexemType.QuestionMark)) node = new TypeSignature(null, "?", node); else return node; } }
/// <summary> /// Resolves a type by its string signature. /// </summary> public Type ResolveType(TypeSignature signature) { Type cached; if (_Cache.TryGetValue(signature.FullSignature, out cached)) return cached; var type = parseTypeSignature(signature); if (type != null) _Cache.Add(signature.FullSignature, type); return type; }
/// <summary> /// Parses the type signature. /// </summary> private Type parseTypeSignature(TypeSignature signature) { try { if (!string.IsNullOrEmpty(signature.Postfix)) return processPostfix(parseTypeSignature(signature.Arguments[0]), signature.Postfix); var name = signature.Name; var hasArgs = signature.Arguments != null && signature.Arguments.Length > 0; if (hasArgs) name += "`" + signature.Arguments.Length; if (TypeAliases.ContainsKey(name)) return TypeAliases[name]; var type = findType(name); return hasArgs ? GenericHelper.MakeGenericTypeChecked(type, signature.Arguments.Select(parseTypeSignature).ToArray()) : type; } catch (ArgumentException ex) { throw new LensCompilerException(ex.Message, signature); } }
protected bool Equals(TypeSignature other) { var basic = string.Equals(Name, other.Name) && string.Equals(Postfix, other.Postfix); if (!basic || (Arguments == null ^ other.Arguments == null)) return false; return Arguments == null || Arguments.SequenceEqual(other.Arguments); }
/// <summary> /// Builds the full string representation of the signature tree. /// </summary> private string getSignature(string name, TypeSignature[] args) { if (args.Length == 0) return name; if (!string.IsNullOrEmpty(Postfix)) return Arguments[0].FullSignature + Postfix; var sb = new StringBuilder(name); sb.Append("<"); var idx = 0; foreach (var curr in args) { if (idx > 0) sb.Append(", "); sb.Append(curr.FullSignature); idx++; } sb.Append(">"); return sb.ToString(); }
/// <summary> /// Resolves a type by its string signature. /// Warning: this method might return a TypeBuilder as well as a Type, if the signature points to an inner type. /// </summary> public Type ResolveType(string signature) { return(ResolveType(TypeSignature.Parse(signature))); }
public FunctionArgument(string name, TypeSignature type, bool isRefArg = false) { Name = name; TypeSignature = type; IsRefArgument = isRefArg; }
public DefaultOperatorNode(TypeSignature type = null) { TypeSignature = type; }
/// <summary> /// Resolves a type by its signature. /// </summary> public Type ResolveType(TypeSignature signature, bool allowUnspecified = false) { if (allowUnspecified && signature.FullSignature == "_") return null; var declared = FindType(signature.FullSignature); return declared != null ? declared.TypeInfo : _TypeResolver.ResolveType(signature); }