Skip to content
  1. Mar 14, 2013
    • Nick Lewycky's avatar
    • John McCall's avatar
      Flag that friend function definitions are "late parsed" so that · e68672fe
      John McCall authored
      template instantiation will still consider them to be definitions
      if we instantiate the containing class before we get around
      to parsing the friend.
      
      This seems like a legitimate use of "late template parsed" to me,
      but I'd appreciate it if someone responsible for the MS feature
      would look over this.
      
      This file already appears to access AST nodes directly, which
      is arguably not kosher in the parser, but the performance of this
      path matters enough that perpetuating the sin is justifiable.
      Probably we ought to reconsider this policy for very simple
      manipulations like this.
      
      The reason this entire thing is necessary is that
      function template instantiation plays some very gross games
      in order to not associate an instantiated function template
      with the class it came from unless it's a definition, and
      the reason *that's* necessary is that the AST currently
      cannot represent the instantiation history of individual
      function template declarations, but instead tracks it in
      common for the entire function template.  That probably
      prevents us from correctly reporting ill-formed calls to
      ambiguously instantiated friend function templates.
      
      rdar://12350696
      
      llvm-svn: 177003
      e68672fe
    • Argyrios Kyrtzidis's avatar
      59852367
    • Argyrios Kyrtzidis's avatar
      [modules] Check for delegating constructor cycles when building a module and... · ffb3558b
      Argyrios Kyrtzidis authored
      [modules] Check for delegating constructor cycles when building a module and don't write them out to the module file.
      
      llvm-svn: 177000
      ffb3558b
    • Rafael Espindola's avatar
      Avoid computing the linkage too early. Don't invalidate it. · 0e0d0097
      Rafael Espindola authored
      Before this patch we would compute the linkage lazily and cache it. When the
      AST was modified in ways that could change the value, we would invalidate the
      cache.
      
      That was fairly brittle, since any code could ask for the a linkage before
      the correct value was available.
      
      We should change the API to one where the linkage is computed explicitly and
      trying to get it when it is not available asserts.
      
      This patch is a first step in that direction. We still compute the linkage
      lazily, but instead of invalidating a cache, we assert that the AST
      modifications didn't change the result.
      
      llvm-svn: 176999
      0e0d0097
  2. Mar 13, 2013
  3. Mar 12, 2013
Loading