vim/YouCompleteMe
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
992769cc2e
YouCompleteMe/cpp/ycm/ClangCompleter/TranslationUnit.h

106 lines
2.9 KiB
C
Raw Normal View History

Changing copyright headers from me to Google When I initially released this project, I released it under my own copyright. I have since then worked on it in my 20% time at Google (and want to continue doing this) and my life becomes much simpler if the copyright is Google's. From the perspective of how this project is run and managed, **NOTHING** changes. YCM is not a Google product, merely a project run by someone who just happens to work for Google. Please note that the license of the project is **NOT** changing. People sending in future pull requests will have to sign the Google [CLA](https://developers.google.com/open-source/cla/individual) (you can sign online at the bottom of that page) before those pull requests could be merged in. People who sent in pull requests that were merged in the past will get an email from me asking them to sign the CLA as well.
2014-01-13 14:08:43 -05:00
// Copyright (C) 2011, 2012 Google Inc.
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
//
// This file is part of YouCompleteMe.
//
// YouCompleteMe is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// YouCompleteMe is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
#ifndef TRANSLATIONUNIT_H_XQ7I6SVA
#define TRANSLATIONUNIT_H_XQ7I6SVA
#include "UnsavedFile.h"
#include "Diagnostic.h"
GoToDefinition/Declaration commands for C-family These are accessible through the :YcmCompleter command. The docs have more information.
2013-03-31 23:38:29 -04:00
#include "Location.h"
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
GoToDefinition/Declaration commands for C-family These are accessible through the :YcmCompleter command. The docs have more information.
2013-03-31 23:38:29 -04:00
#include <clang-c/Index.h>
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
#include <boost/utility.hpp>
#include <boost/thread/mutex.hpp>
#include <string>
#include <vector>
Formatting the a part of the source with astyle
2013-01-19 23:03:32 -05:00
namespace YouCompleteMe {
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
struct CompletionData;
typedef boost::shared_ptr< std::vector< CompletionData > > AsyncCompletions;
Formatting the a part of the source with astyle
2013-01-19 23:03:32 -05:00
class TranslationUnit : boost::noncopyable {
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
public:
Race condition fix; caused latency on first load The issue was that the user could open a C-family file and have it start compiling in the background. While it is still compiling, he could trigger the completion system with a member dot operator. Because the file was still compiling for the very first time, the TranslationUnit object was yet not created. Sadly, this meant that UpdatingTranslationUnit would return false, and a new query request would be created, the GUI would hang until it was done aaaaand terrible lag until the file was compiled. This was a very rare edge case that could also only be triggered if it takes a considerable amount of time to compile the file.
2013-01-24 21:37:44 -05:00
// This constructor creates an invalid, sentinel TU. All of it's methods
// return empty vectors, and IsCurrentlyUpdating always returns true so that
// no callers try to rely on the invalid TU.
TranslationUnit();
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
TranslationUnit(
const std::string &filename,
const std::vector< UnsavedFile > &unsaved_files,
const std::vector< std::string > &flags,
CXIndex clang_index );
~TranslationUnit();
Managing memory from the C interface better
2013-01-22 22:40:05 -05:00
void Destroy();
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
std::vector< Diagnostic > LatestDiagnostics();
bool IsCurrentlyUpdating() const;
Fixing the diagnostic-related race conditions Now, every FileReadyToParse event returns diagnostics, if any. This is instead of the previous system where the diagnostics were being fetched in a different request (this caused race conditions).
2013-10-03 16:15:43 -04:00
std::vector< Diagnostic > Reparse(
Running style_format.sh on codebase
2013-10-29 22:13:52 -04:00
const std::vector< UnsavedFile > &unsaved_files );
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
GoToDefinition/Declaration commands for C-family These are accessible through the :YcmCompleter command. The docs have more information.
2013-03-31 23:38:29 -04:00
void ReparseForIndexing( const std::vector< UnsavedFile > &unsaved_files );
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
std::vector< CompletionData > CandidatesForLocation(
Formatting the a part of the source with astyle
2013-01-19 23:03:32 -05:00
int line,
int column,
const std::vector< UnsavedFile > &unsaved_files );
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
GoToDefinition/Declaration commands for C-family These are accessible through the :YcmCompleter command. The docs have more information.
2013-03-31 23:38:29 -04:00
Location GetDeclarationLocation(
int line,
int column,
const std::vector< UnsavedFile > &unsaved_files );
Location GetDefinitionLocation(
int line,
int column,
const std::vector< UnsavedFile > &unsaved_files );
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
GoToDefinition/Declaration commands for C-family These are accessible through the :YcmCompleter command. The docs have more information.
2013-03-31 23:38:29 -04:00
private:
Handling clang parse errors instead of segfaulting
2012-08-13 23:51:04 -04:00
void Reparse( std::vector< CXUnsavedFile > &unsaved_files );
GoToDefinition/Declaration commands for C-family These are accessible through the :YcmCompleter command. The docs have more information.
2013-03-31 23:38:29 -04:00
void Reparse( std::vector< CXUnsavedFile > &unsaved_files,
uint parse_options );
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
void UpdateLatestDiagnostics();
GoToDefinition/Declaration commands for C-family These are accessible through the :YcmCompleter command. The docs have more information.
2013-03-31 23:38:29 -04:00
CXCursor GetCursor( int line, int column );
Refactored the clang completer; many bugs fixed This change should fix the random hangs and segfaults when using the clang completer. Also, assertion errors printed to the console on vim exit should go away too, same thing with segfaults on vim exit. These "on exit" errors were caused by not cleanly shutting down the background threads; both the identifier completer and the clang one now join the threads on destruction. This results in a clean shutdown. The new clang completer architecture now uses only one clang thread (again) instead of a completion and parsing thread. Since the parsing task needs to wait on the completion task if it was started first (and vice-versa) there's no point to using two threads. The desired "simplicity" of using two threads for these two tasks actually created needless complexity (and bugs). Sigh. Such is life. A TranslationUnit abstraction was also created and this in turn also reduces the complexity of the clang completer. The clang completer now also has some (very) basic tests.
2012-08-11 22:27:15 -04:00
/////////////////////////////
// PRIVATE MEMBER VARIABLES
/////////////////////////////
std::string filename_;
boost::mutex diagnostics_mutex_;
std::vector< Diagnostic > latest_diagnostics_;
mutable boost::mutex clang_access_mutex_;
CXTranslationUnit clang_translation_unit_;
};
} // namespace YouCompleteMe
#endif /* end of include guard: TRANSLATIONUNIT_H_XQ7I6SVA */
Reference in New Issue Copy Permalink