obj.Flagcount("live", "debug liveness analysis", &debuglive)
        obj.Flagcount("m", "print optimization decisions", &Debug['m'])
        obj.Flagcount("msan", "build code compatible with C/C++ memory sanitizer", &flag_msan)
-       obj.Flagcount("newexport", "use new export format", &newexport) // TODO(gri) remove eventually
-       obj.Flagcount("oldparser", "use old parser", &oldparser)        // TODO(gri) remove eventually
+       obj.Flagcount("newexport", "use new export format", &newexport) // TODO(gri) remove eventually (issue 13241)
+       obj.Flagcount("oldparser", "use old parser", &oldparser)        // TODO(gri) remove eventually (issue 13240)
        obj.Flagcount("nolocalimports", "reject local (relative) imports", &nolocalimports)
        obj.Flagstr("o", "write output to `file`", &outfile)
        obj.Flagstr("p", "set expected package import `path`", &myimportpath)
        // to the yacc-based parser. Short-term work-around for issues with
        // the new recursive-descent parser for which setting -oldparser is
        // not sufficient.
-       // TODO(gri) remove this eventually
+       // TODO(gri) remove this eventually (issue 13240)
        //
        // oldparser = 1
 
 
 
 // TODO(gri) Once we handle imports w/o redirecting the underlying
 // source of the lexer we can get rid of these. They are here for
-// compatibility with the existing yacc-based parser setup.
+// compatibility with the existing yacc-based parser setup (issue 13242).
 var thenewparser parser // the parser in use
 var savedstate []parser // saved parser state, used during import
 
 }
 
 // TODO(gri) figure out why yyTokname doesn't work for us as expected
+// (issue 13243)
 var tokstrings = map[int32]string{
        LLITERAL:           "LLITERAL",
        LASOP:              "op=",
        fmt.Printf("%5d: ", lineno)
 
        // TODO(gri) imports screw up p.indent - fix this
+       // (issue 13243)
        if p.indent < 0 {
                p.indent = 0
        }
                p.advance(';', ')')
        }
 
-       line := parserline() // TODO(gri) check correct placement of this
+       line := parserline() // TODO(gri) check correct placement of this (issue 13243)
        importfile(&path, line)
        return line
 }
        }
        popdcl()
 
-       p.want('}') // TODO(gri) is this correct location w/ respect to popdcl()?
+       p.want('}') // TODO(gri) is this correct location w/ respect to popdcl()? (issue 13243)
 
        return stmt
 }
 
        stmt.Nbody = p.stmt_list()
 
-       // TODO(gri) what do we need to do here?
+       // TODO(gri) what do we need to do here? (issue 13243)
        // // This is the only place in the language where a statement
        // // list is not allowed to drop the final semicolon, because
        // // it's the only place where a statement list is not followed
 }
 
 // TODO(gri) should have lexer return this info - no need for separate lookup
+// (issue 13244)
 var prectab = map[int32]struct {
        prec int // > 0 (0 indicates not found)
        op   Op
                op = ONOT
 
        case '~':
-               // TODO(gri) do this in the lexer instead
+               // TODO(gri) do this in the lexer instead (issue 13244)
                p.next()
                x := p.uexpr()
                Yyerror("the bitwise complement operator is ^")
                //
                // TODO(gri) could simplify this if we parse complits
                // in operand (see respective comment in pexpr).
+               //
+               // (We can probably not do this because of qualified types
+               // as in pkg.Type{}) (issue 13243).
                if keep_parens || p.tok == '{' {
                        return Nod(OPAREN, x, nil)
                }
                case '{':
                        // TODO(gri) should this (complit acceptance) be in operand?
                        // accept ()'s around the complit type but complain if we have a complit
+                       // (issue 13243)
                        t := x
                        for t.Op == OPAREN {
                                t = t.Left
        //      x = Nod(OPAREN, x, nil)
        //      x.Implicit = true
        // }
+       // (issue 13243)
        return x
 }
 
        case LDDD:
                // permit ...T but complain
                // TODO(gri) introduced for test/fixedbugs/bug228.go - maybe adjust bug or find better solution
+               // (issue 13243)
                p.syntax_error("")
                p.advance()
                return p.ntype()
 
 // go.y:fnret_type
 // TODO(gri) only called from fnres - inline and remove this one
+// (issue 13243)
 func (p *parser) fnret_type() *Node {
        if trace && Debug['x'] != 0 {
                defer p.trace("fnret_type")()
        }
 
        // TODO(gri) make this more tolerant in the presence of LDDD
-       // that is not at the end.
+       // that is not at the end (issue 13243).
 
        for p.tok != EOF && p.tok != ')' && !ddd {
                l = list(l, p.expr()) // expr_or_type
        }
 
        // TODO(gri) possible conflict here: both cases may start with '@' per grammar
+       // (issue 13245).
+
        switch p.tok {
        case LNAME, '@', '?':
                s1 := p.sym()