Summary: 307 instances, 286 unique

Text	Count
print("// FIXME: get group transform out of here!")	1
/// TODO: Could have an Error existential area instead	1
// TODO: worth having?	1
// FIXME: Possessive needs a "dummy" save point to ratchet	1
// TODO: comments, non-semantic whitespace, etc.	1
// TODO: Explicitly implement the non-matching consumer/searcher protocols as	1
// TODO: multi-line if long	1
return g // FIXME: get this out of here	1
// TODO: `maxSplits`, `omittingEmptySubsequences`?	1
// TODO: save registers?	1
// TODO: include?	1
// TODO: Place shared formatting and trace infrastructure here	1
// TODO: Do we want to represent capture metadata?	1
// TODO: If we want a strict Oniguruma mode, we'll need to add a check	1
fatalError("FIXME: extended AST?")	1
// FIXME: semantic level	1
// TODO: Or, do we want to split things out? How should we do this?	1
// TODO: Mutating because of fail address fixup, drop when	1
// TODO: Would our model type for character classes include	1
// TODO: non-primitive construction	2
case escaped(EscapedBuiltin) // TODO: expand this out	1
// TODO: BinaryInteger, etc.	1
return " /* TODO: callout */"	1
// FIXME: Calling on inverted sets wont be the same as the	1
// TODO: Custom `SubSequence` for the sake of more efficient slice iteration	2
// TODO: this is double calculated	1
// TODO: drop the filtering when fake-ness is taken out of	1
// TODO: Shouldn't this be parameterized over matching	1
// TODO: more efficient to have native support	1
fatalError("FIXME: Let's not keep the boxed existential...")	3
// TODO: Trace Core	1
// TODO:	1
throw unsupported("TODO: map PCRE special: \(s)")	1
// TODO: We'll want to bake backwards into the engine	1
// FIXME: We shouldn't be returning `nil` here, but instead fixing the call	1
// TODO: We want variadic generics!	1
return " /* TODO: backtracking directive */"	1
// FIXME: Is this re-entrant? That is would nested	1
output("/* TODO: get groupTransform out of AST */")	1
// TODO: better description	1
// TODO: This is basically an AST interpreter, which would	1
// TODO: Capture metadata	1
return "/* TODO: named reference \(self) */"	1
// TODO: We may want to diagnose and require users to disambiguate, at least	1
// FIXME: How should we handle bounds?	1
// TODO: Which should we prefer, this or `\g{n}`?	1
// TODO: Better AST types here	1
// TODO: Interact with capture info	1
// TODO: Perhaps a syntax options check (!PCRE)	1
// TODO: Is the above actually a good idea? Should we just	1
// TODO: Array permitting uninitialized values	1
// TODO: Diagnose on nested absent functions, which Oniguruma states is	1
// TODO: throw or otherwise propagate	1
// TODO: Match level?	1
// TODO: Replace all fatal error unreachables with these calls.	1
// TODO: We'd like to use shadow bits to assert on kind	1
// FIXME: This is mostly hacky because we go down two different paths based on	1
/// TODO: Not sure if this the right model type, but I suspect we'll want to produce	1
// TODO: more	1
// FIXME: Count number of `#` in literal...	1
// TODO: semantic level	1
// TODO: (name:)	1
// TODO: SmallVector-like struct, as almost always 1 or 2 length.	1
// TODO: post conditions	1
return "/* TODO: scriptRun */"	1
// TODO: We might scrap this and break out a few categories so	1
/// TODO: Consider if separating would improve generality	1
// TODO: Design an "unsafe" and "assumingValid" API convention	1
"/* TODO: character properties */"	1
// TODO: opcode specific rendering	1
// TODO: This might be interesting in the future, but for now	1
// TODO: Escaping?	1
/// TODO: We want to coalesce adjacent atoms, likely in	1
// TODO: We ought to try and consume whitespace here and emit a	1
// TODO: Should we error?	1
// TODO: We should probably advise users to use the more explicit	1
return "/* TODO: relative reference \(self) */"	1
// FIXME: Wait, how does this work?	1
// FIXME: Get this out of here	1
print("// TODO: Range \(r.lhs) to \(r.rhs)")	1
// TODO: This actually might be good module API fodder	1
// TODO: A recursive call isn't a backreference, but	1
// TODO: reversed matches	1
case label(LabelId) // TODO: separate out	1
// TODO: We'll want to bake search into the engine so it can	1
// TODO: deduplicate this logic with `StatelessCollectionSearcher`?	1
// TODO: track source locations	1
// FIXME: CharacterClass wasn't designed for set operations with	1
// TODO: compile directly	1
// TODO: `Collection` conformance	3
// TODO: Warn about whitespace being included?	1
// TODO: implement BackwardCollectionSearcher	1
return "/* TODO: negativeLookbehind */"	1
// FIXME: ICU can read up to 3 octal digits if the leading digit is 0,	1
TODO: Conjectures:	1
// TODO: State transitions need more work. We want	1
TODO: Specialized data structure for all captures:	1
// TODO: We might want to output comments...	2
return " /* TODO: keyboard meta-control */"	1
// TODO: This implicit scoping behavior matches Oniguruma, but PCRE	1
// TODO: What about precedence?	1
// TODO: Global matching options?	2
// TODO: but really, let's come up with something	1
// TODO: Not optimal.	1
// FIXME: empty ranges, etc...	1
print("/*TODO: absent function \(abs)*/")	1
/// TODO: Swift-style nested comments, line-ending comments, etc	1
// TODO: better names for accept/fail/etc. Instruction	1
return " /* TODO: subpattern */"	1
// TODO: codegen that will update stack instead of pop/push	1
return "/* TODO: negativeLookahead */"	1
// TODO: alias? casing?	1
// TODO: Without bit packing our representation, what	1
// TODO: consider let, for now lets us toggle tracing	1
// TODO: bounds check	1
//        fatalError("TODO: Map categories: \(p)")	1
// TODO: Avoid a potential copy-on-write copy here	1
// TODO: We probably want this to be a prperty after group	1
// FIXME: Semantic level, vet for precise defs	2
// TODO: This will add a fail instruction at the end every	1
return "/* TODO: changeMatchingOptions */"	1
// TODO: any way around the RRC copying init?	1
throw unsupported("TODO: map other \(key ?? "")=\(value)")	1
// FIXME: better printing...	1
// TODO: save call stack position?	1
// TODO: Is this really what we want?	1
// TODO: any way to assert or guarantee this is called	1
// TODO: May want to consider Unicode level	2
// TODO: semantic level?	1
// TODO: save capture position?	1
// TODO: I wonder if it makes sense to store the string.	1
// TODO: Debug stream	1
// TODO: A register-mapping helper struct, which could release	1
// TODO: Could builder provide a generalized mapping table?	1
// TODO: How should we handle bounds?	2
// TODO: Avoid calling `state(for:startingAt)` here	2
// TODO: append, and all the other customization hooks...	1
// TODO: Bake in search-back to engine too	1
// TODO: Better API for the parser to throw located errors.	1
return "/* TODO: lookbehind */"	1
// TODO: We should eventually have some way of filtering out trivia for	1
// TODO: Replace with real set vector	1
// TODO: refactor loop body into function	1
// TODO: is this modeled differently?	1
// TODO: bounds check?	1
// FIXME: newline sequence is not same as \n	1
// TODO:	1
return " /* TODO: keyboard meta */"	1
// TODO: Which order is better?	1
// TODO: erm, separate out or fold into something? splat it in?	1
// TODO:	1
/// TODO: Need to support some escapes	1
return "/* TODO: atomicScriptRun */"	1
// TODO: This is convoluted. Surely it can be coded using better	1
// TODO: Or should this assign to a register?	1
// TODO: Do we need grouping or special escape rules?	1
// TODO: This doesn't appear to be followed by ICU or Oniguruma, so	1
// TODO: Make this reusable	2
// TODO: codegen that will count	1
output("/* TODO: set operation \(self) */")	1
return "(/* TODO: matchign options in canonical form */"	1
// TODO: We can probably build a nice model with API here	1
// TODO: Matching vs asserting...	1
// TODO: Add an expansion level, both from top to bottom.	1
// TODO: Are captured pre-order or post-order?	1
return "/* TODO: lookahead */"	1
// TODO: more efficient to have native support	1
// TODO: Normalize these?	1
// TODO: What should we do if `f` never returns non-nil?	1
// TODO: Parser should warn	2
// TODO: Wean ourselves off of this type...	1
// TODO: Consider captures an PC/SP pair, requires ability to	1
// TODO: might be more efficient to compile directly?	1
// TODO: should this be throwing, constant evaluable, or	1
var bools: [Bool] // TODO: bitset	1
// FIXME: Save minimal info (e.g. stack position and	1
// TODO: Validate the types of characters that can appear in the name?	1
// TODO: Probably want to model strict-PCRE etc. options too.	1
// FIXME: semantic levels, modes, etc	1
// TODO: Fixits, notes, etc.	1
// TODO: We should ideally be able to recover from a regex with missing	1
// TODO: prettier printing	1
// TODO: Oniguruma can parse an additional recursion level for	1
// TODO: PCRE allows escaped delimiters or '\Q...\E' sequences in the	1
// TODO: Remove this branch when the matching engine supports captures.	1
// TODO: Split out builtin character classes into their own type?	1
return "/* TODO: balanced captures */"	1
throw unsupported("TODO: cased letter? not the property?")	1
// TODO: We should probably have a component type	1
// FIXME: Move off the regex literal AST	1
// TODO: Is this the right place to do function stack unwinding?	1
// TODO: Should `Regex` itself implement these protocols?	1
throw unsupported("TODO: Map script: \(s)")	2
// TODO: Pre-allocated register banks	1
throw unsupported("TODO: map Oniguruma special: \(s)")	1
return "/* TODO: nonAtomicLookbehind */"	1
// TODO: Do we need to save any registers?	1
// TODO: We want a better strategy for fixups, leaving	1
// TODO: Are callouts quantifiable?	1
// TODO: We could have better recovery here if we only ate the characters	1
// TODO: Diagnostics engine, recorder, logger, or similar.	1
// FIXME: based on opcode, decide if we split...	1
// TODO: Warn on duplicate options, and options appearing in both adding	1
output("(/*TODO: conditional \(condition) */)")	1
// TODO: Not a character per-say, what should we do?	1
// TODO: Linear is probably fine...	1
// TODO: check for out of bounds?	1
// FIXME: better def	2
// TODO: Non-escaping and throwing	2
// FIXME: Is this right for custom char classes?	1
// TODO: Which bunny to return? Longest, left most, or what?	1
// FIXME: Figure out how to communicate this out	1
// TODO: We should choose operand ordering based on codegen	1
// TODO: it's not clear if error is bound earlier or	1
// TODO: Avoid infinite behavior from (a*)*. This happens because `readThrough`	1
// TODO: semantic level	1
// TODO: clarify difference between this and	1
_ = capture // TODO: construct structure	1
// TODO: generic	1
return "/* TODO: atomicNonCapturing */"	1
// TODO: Better to count loop iterations...	1
// TODO: consider pruning anything in the rendered	1
// TODO: `@discardableResult`?	1
TODO: We probably want to allow participants to register	1
throw unsupported("TODO: map prop \(self)")	1
fatalError("TODO: What should we do here?")	1
// TODO: Assert that all newly added suspension points	1
// FIXME: should we worry about out of bounds?	1
// TODO: Needs to track group number resets (?|...).	1
// Backtracking (TODO: should this be explicit slots or implicit stack?)	1
// TODO: deduplicate this logic with `StatelessBackwardCollectionSearcher`?	1
return "/* TODO: non-capture reset */"	1
return " /* TODO: back reference */"	1
// TODO: source should hold outer collection and range, at least	1
// FIXME: We may have to re-introduce escapes	1
print("/*TODO: conditional \(c)*/")	1
// TODO: Validating versions that remove that aspect of	1
case custom(() -> Bool) // TODO: Matching state to closure	1
// TODO: API names instead of case names	1
// TODO: Fused assertions. It seems like we often want to	1
// TODO: builder.buildAdvanceUnicodeScalar(1)	1
// TODO: PCRE offers a different behavior if PCRE2_ALT_BSUX is set.	1
// TODO: Just remember them as we compile	1
// TODO: mock up multi-line soon	1
/// TODO: Isn't this a strong since instead of weak since?	2
// TODO: Is the amount useful here? Is it commonly more than 1?	1
// TODO: placeholder bit pattern for fill-in-later	1
// TODO: Round-tripping tests	1
// TODO: check invariants	2
// TODO: Be generic over the pattern?	1
print("// TODO: Set operation: \(member)")	1
return " /* TODO: keyboard control */"	1
// TODO: What if lengths don't line up?	1
// TODO: Need to map our registers over...	1
// TODO: Should empty stack mean success?	1
// TODO: internal after compiler moves in	1
TODO: We will probably want defaulting mechanisms, such as:	1
// TODO: Release/reuse registers, for now nop makes	3
// TODO: Use a more efficient search algorithm	1
// FIXME: This should apply to future groups too.	1
// TODO: What all do we want to save? Configurable?	1
// TODO: We want to be `String` instead of `[Character]`...	1
// FIXME: Below is largely scalar based, for convenience,	1
// TODO: Consider UTF-16 support, but that's normally best	1
case invalidUTF8 // TODO: better range reporting	1
return " /* TODO: named character */"	1
// TODO: optionality of return? Probably a good idea to signal if something happened...	1
return "/* TODO: atom \(self) */"	1
// TODO: Should pop assign to register, or current pc, or what?	1
// TODO: replace with instruction formatters...	1
// TODO: Support heterogeneous capture alternation.	1
// FIXME: Depends on API model we have... We may want to	1
// TODO: If empty, probably need empty range or something...	1
// TODO: Can we try and recover and diagnose these outside character	1
// TODO: Consumers need a concept of forward progress.	1
// FIXME: Semantic level	1
// TODO: what here should be in the compile-time module?	1
// TODO: bounds check?	1
/// TODO: These should become aliases for the Block (blk) Unicode character	1
return "/* TODO: nonAtomicLookahead */"	1
// FIXME: implement	1
// FIXME: Other kinds...	1
// TODO: Extract into formatting code	1
// TODO: Store customCC in the atom, if that's useful	1
// TODO: backtrace, etc.	1
print("// TODO: quote \(q.literal._quoted) in custom character classes (should we split it?)")	1