Lines Matching refs:Anonymous
128 * Anonymous appears in the generated code but cannot be unified
133 static TupleKindPtr Anonymous("Anonymous");
156 * Return the name of this tuple kind, unless it is the special Anonymous
161 if (Anonymous.get() == this)
174 /* A tuple kind that represents an anonymous pair of nested tuple kinds.
263 /* Is this a kind of object representing an anonymous function?
267 return size() != 0 && back() == Anonymous;
277 /* Is this a kind of object with a single, anonymous tuple?
440 * is an identifier (with an anonymous tuple).
442 static Signature bin_params_anon = { { }, { { }, { Anonymous } } };
443 static Signature bin_set_anon = { { Domain }, { { Domain }, { Anonymous } } };
445 { { Domain, Range }, { { Domain, Range }, { Anonymous } } };
470 /* Signatures for naming a leaf tuple using an identifier (with an anonymous
473 static Signature update_set = { { Domain2 }, { { Leaf }, { Anonymous } } };
475 { { Domain2, Range }, { { Leaf, Range }, { Anonymous } } };
477 { { Domain, Range2 }, { { Domain, Leaf }, { Anonymous } } };
491 { { Domain }, { { }, { Anonymous }, { Integer } } };
493 { { Domain, Range }, { { Domain }, { Anonymous }, { Integer } } };
573 /* Signatures for creating an anonymous set from a parameter set
574 * or a map from a domain, where the range is anonymous.
576 static Signature anonymous_set_from_params = { { Anonymous }, { { } } };
578 { { Domain, Anonymous }, { { Domain } } };
582 /* Signatures for creating an anonymous function from a domain,
583 * where the second argument is an identifier (with an anonymous tuple).
586 { { Anonymous }, { { }, { Anonymous } } };
588 { { Domain, Anonymous }, { { Domain }, { Anonymous } } };
685 * replacing it with either an anonymous tuple or a tuple with a given name.
688 { { Anonymous, Range2 }, { { { Domain, Range }, Range2 } } };
690 { { Domain, Anonymous }, { { Domain, { Range, Range2 } } } };
693 { { { Domain, Range }, Range2 }, { Anonymous} } };
695 { { Domain, Range3 }, { { Domain, { Range, Range2 } }, { Anonymous} } };
704 { { Domain }, { { Domain }, { Integer }, { Anonymous } } };
707 { { Domain, Range }, { Integer }, { Domain, Anonymous } } };
713 static Signature to_list_set = { { Anonymous }, { { Domain } } };
714 static Signature to_list_map = { { Domain, Anonymous }, { { Domain, Range } } };
928 static Signature from_list_set = { { Domain }, { { Domain }, { Anonymous } } };
930 { { Domain, Range }, { { Domain, Range }, { Domain, Anonymous } } };
932 { { Domain, Range }, { { Range }, { Domain, Anonymous } } };
985 * the last of which may be anonymous.
989 static Kind set_anon{ Anonymous };
991 static Kind map_anon{ Domain, Anonymous };
998 * a given type can have and whether it is anonymous.
1003 * "aff" can have one or two tuples, the last of which is anonymous.
1005 * "val" and "id" are treated as anonymous sets so that
1065 /* A mapping from anonymous kinds to named kinds.
1072 /* Given a sequence of anonymous kinds, replace them
1090 * from an anonymous function type. Replace the final Anonymous
1157 * For template classes that represent an anonymous function
1159 * that adds the fixed Anonymous tuple kind.
1178 << name << "<Ts..., Anonymous>;\n";
1926 static Signature int_from_si = { { Anonymous }, { { Ctx }, { Integer } } };
1947 * to that of the first argument, except that the final tuple is anonymous.
1979 /* Does this template class represent an anonymous function?
1981 * If any specialization represents an anonymous function,
1990 /* Does this template class represent an anonymous value?
1993 * has a single, anonymous tuple?
2030 * If "general" is Anonymous, then "specific" must be Anonymous as well.
2043 if (general == Anonymous && specific != Anonymous)
2154 * If the template class represents an anonymous function,
2188 * Anonymous can only be mapped to itself. This is taken care of
2196 return kind != Anonymous && kind != Leaf;
2204 * The latter case handles mapping Anonymous to itself.
2377 * have a final Anonymous tuple?
2380 * have been defined for the type, then it can be considered anonymous.
2381 * Otherwise, if any specialization represents an anonymous function,
2403 /* Replace the final tuple of "arg_kind" by Anonymous in "sig" and
2415 const auto &subs = compute_unifier(arg_kind.back(), Anonymous);
2425 * has a final Anonymous tuple, but the corresponding entry
2426 * in the signature "sig" is not Anonymous, then replace
2427 * that entry by Anonymous and return the updated signature,
2461 * specialize any anonymous arguments,
2555 * which make the final tuple anonymous.
2557 static Signature select_set = { { Anonymous }, { { Domain }, { Integer } } };
2559 { { Domain, Anonymous
2576 * In the first case, the return type is an anonymous function
2578 * should have a final Anonymous tuple.
2849 * If the instance kind is that of an anonymous set
2850 * (i.e., it has a single tuple that is set to Anonymous),
2853 * isl::typed::val<Anonymous> interchangeably and similarly for isl::id.
Indexes created Fri Feb 27 05:31:41 UTC 2026