Skip to content
  1. Feb 25, 2011
  2. Feb 23, 2011
  3. Feb 20, 2011
  4. Feb 18, 2011
  5. Feb 16, 2011
  6. Feb 15, 2011
  7. Feb 14, 2011
  8. Feb 05, 2011
  9. Feb 03, 2011
  10. Dec 10, 2010
  11. Dec 01, 2010
  12. Nov 29, 2010
  13. Nov 11, 2010
  14. Jul 30, 2010
  15. Mar 09, 2010
  16. Jan 26, 2010
  17. Dec 12, 2009
  18. Nov 22, 2009
  19. Nov 08, 2009
  20. Nov 05, 2009
  21. Nov 03, 2009
  22. Oct 16, 2009
  23. Sep 26, 2009
  24. Sep 24, 2009
  25. Sep 22, 2009
  26. Sep 20, 2009
  27. Sep 17, 2009
    • Douglas Gregor's avatar
      Initial implementation of a code-completion interface in Clang. In · 2436e711
      Douglas Gregor authored
      essence, code completion is triggered by a magic "code completion"
      token produced by the lexer [*], which the parser recognizes at
      certain points in the grammar. The parser then calls into the Action
      object with the appropriate CodeCompletionXXX action.
      
      Sema implements the CodeCompletionXXX callbacks by performing minimal
      translation, then forwarding them to a CodeCompletionConsumer
      subclass, which uses the results of semantic analysis to provide
      code-completion results. At present, only a single, "printing" code
      completion consumer is available, for regression testing and
      debugging. However, the design is meant to permit other
      code-completion consumers.
      
      This initial commit contains two code-completion actions: one for
      member access, e.g., "x." or "p->", and one for
      nested-name-specifiers, e.g., "std::". More code-completion actions
      will follow, along with improved gathering of code-completion results
      for the various contexts.
      
      [*] In the current -code-completion-dump testing/debugging mode, the
      file is truncated at the completion point and EOF is translated into
      "code completion".
      
      llvm-svn: 82166
      2436e711
    • Daniel Dunbar's avatar
      Tweak clang testing. · ecac0a40
      Daniel Dunbar authored
       - Move CMake to using the new test runner.
      
       - Switch Makefiles to use the lit.site.cfg.in template.
      
       - Remove explicit --path arguments, instead this gets written into the site
         configuration. This means running lit from the command line should use the
         exact same configuration as is used in 'make test', assuming it can find the
         site configuration file. You still need to run 'make test' (or the cmake
         build target equivalent) at least once.
      
      llvm-svn: 82160
      ecac0a40
    • Douglas Gregor's avatar
  28. Jul 31, 2009
    • Daniel Dunbar's avatar
      MultiTestRunner: Simplify, cleanup, and rename! · 3667b99a
      Daniel Dunbar authored
       - MultiTestRunner will eventually be renamed to 'lit', for LLVM integrated
         tester/testing. This has the pros of being pronouncable and short.
      
       - "Project" level configuration lives in 'lit.cfg', which is also what lit uses
         to find the root testing directory in some cases. This can be overridden for
         use in project files which want to precisely specify where things are.
      
       - TestRunner.py is not longer able to be invoked directly.
       
       - Moved some code to Util.py.
      
       - Introduced a configuration object.
      
       - Cleaned up --help, removed a few not-very-useful options.
      
       - Tried not to break anything that works. :)
      
      llvm-svn: 77665
      3667b99a
  29. Jul 27, 2009
  30. Jul 02, 2009
    • Douglas Gregor's avatar
      Add support for retrieving the Doxygen comment associated with a given · c6d5edd2
      Douglas Gregor authored
      declaration in the AST. 
      
      The new ASTContext::getCommentForDecl function searches for a comment
      that is attached to the given declaration, and returns that comment, 
      which may be composed of several comment blocks.
      
      Comments are always available in an AST. However, to avoid harming
      performance, we don't actually parse the comments. Rather, we keep the
      source ranges of all of the comments within a large, sorted vector,
      then lazily extract comments via a binary search in that vector only
      when needed (which never occurs in a "normal" compile).
      
      Comments are written to a precompiled header/AST file as a blob of
      source ranges. That blob is only lazily loaded when one requests a
      comment for a declaration (this never occurs in a "normal" compile). 
      
      The indexer testbed now supports comment extraction. When the
      -point-at location points to a declaration with a Doxygen-style
      comment, the indexer testbed prints the associated comment
      block(s). See test/Index/comments.c for an example.
      
      Some notes:
        - We don't actually attempt to parse the comment blocks themselves,
        beyond identifying them as Doxygen comment blocks to associate them
        with a declaration.
        - We won't find comment blocks that aren't adjacent to the
        declaration, because we start our search based on the location of
        the declaration.
        - We don't go through the necessary hops to find, for example,
        whether some redeclaration of a declaration has comments when our
        current declaration does not. Similarly, we don't attempt to
        associate a \param Foo marker in a function body comment with the
        parameter named Foo (although that is certainly possible).
        - Verification of my "no performance impact" claims is still "to be
        done".
      
      llvm-svn: 74704
      c6d5edd2
  31. Jun 18, 2009
  32. Jun 16, 2009
  33. Jun 06, 2009
Loading