Refactor

Reviewers: jerzy.kleszcz, michal.zielinski

Reviewed By: michal.zielinski

Subscribers: jerzy.kleszcz, michal.zielinski

Differential Revision: https://phabricator.polidea.com/D2903

swift/include/swift/Obfuscation/Collector.h

@@ -0,0 +1,32 @@
+#ifndef Collector_h
+#define Collector_h
+
+#include "swift/Obfuscation/DataStructures.h"
+#include "swift/Obfuscation/Includer.h"
+#include "swift/Obfuscation/SymbolGenerator.h"
+
+#include <vector>
+
+namespace swift {
+namespace obfuscation {
+
+class Collector {
+
+private:
+  std::unique_ptr<class Includer> Includer;
+  std::unique_ptr<class SymbolGenerator> SymbolGenerator;
+
+public:
+
+  Collector(std::unique_ptr<class Includer>,
+            std::unique_ptr<class SymbolGenerator>);
+
+  std::vector<DeclWithSymbolWithRange> collectFrom(DeclWithRange &);
+  std::vector<DeclWithSymbolWithRange> collectFrom(DeclWithRange &&);
+
+};
+
+} //namespace obfuscation
+} //namespace swift
+
+#endif /* Collector_h */

swift/include/swift/Obfuscation/CompilerInfrastructure.h

@@ -18,25 +18,27 @@ namespace obfuscation {
 ///
 /// Typical usage:
 /// \code
-/// auto FilesJsonOrError = parseJson<FilesJson>(PathToJson);
-/// if (auto Error = setupCompilerInstance(CI, FilesJson, MainExecutablePath)) {
+/// auto CompilerInstanceOrError =
+///   createCompilerInstance(FilesJson, MainExecutablePath);
+/// if (auto Error = CompilerInstanceOrError) {
 ///   return std::move(Error);
 /// }
+/// auto CompilerInstance = CompilerInstanceOrError.get();
 /// \endcode
 ///
-/// \param CompilerInstance - compiler instance to setup.
+/// \param FilesJson - FilesJson structure containing data required
+///                    for compilation.
 ///
 /// \param MainExecutablePath - string containing path to main executable used
 /// during compiler isntance 
 ///
 /// \returns llvm::Error::success when setup finished correctly or
 /// error object describing cause of fail.
-llvm::Error
-setupCompilerInstance(CompilerInstance &CompilerInstance,
-                      const FilesJson &FilesJson,
-                      std::string MainExecutablePath,
-                      llvm::raw_ostream &LogStream);
-
+llvm::Expected<std::unique_ptr<CompilerInstance>>
+createCompilerInstance(const FilesJson &FilesJson,
+                       std::string MainExecutablePath,
+                       llvm::raw_ostream &LogStream);
+
 } //namespace obfuscation
 } //namespace swift
 

swift/include/swift/Obfuscation/DataStructures.h

@@ -101,7 +101,8 @@ struct SymbolRenaming {
          const std::string &ObfuscatedName,
          const std::string &Module,
          SymbolType Type);
-
+
+  bool operator< (const SymbolRenaming &Right) const;
   bool operator== (const SymbolRenaming &Right) const;
 };
 
@@ -169,7 +170,7 @@ struct ObfuscationConfiguration {
   ObfuscationConfiguration& operator=(const ObfuscationConfiguration &) = delete;
   ObfuscationConfiguration& operator=(ObfuscationConfiguration &&) = default;
 };
-  
+
 /// SymbolWithRange - struct for linking the symbol identified in the Swift
 /// source code with the range in which it was encountered.
 struct SymbolWithRange {
@@ -187,35 +188,91 @@ struct SymbolWithRange {
   bool operator== (const SymbolWithRange &Right) const;
 };
 
-struct IndexedSymbolWithRange {
+enum DeclarationProcessingContext {
+  NoContext,
+
+  FunctionCallAttribute
+};
+
+struct DeclWithRange {
+  Decl *Declaration;
+  CharSourceRange Range;
+  DeclarationProcessingContext Context;
+
+  /// @brief Trivial memberwise-like constructor
+  DeclWithRange(Decl* Declaration, const CharSourceRange &Range);
+
+  bool operator< (const DeclWithRange &Right) const;
+
+  bool operator== (const DeclWithRange &Right) const;
+};
+
+struct DeclWithSymbolWithRange {
+  Decl *Declaration;
+  Symbol Symbol;
+  CharSourceRange Range;
+
+  /// @brief Trivial memberwise-like constructor
+  DeclWithSymbolWithRange(Decl* Declaration,
+                          const SymbolWithRange &SymbolAndRange);
+
+  DeclWithSymbolWithRange(const DeclWithRange &DeclAndRange,
+                          const struct Symbol &Symbol);
+
+  DeclWithSymbolWithRange(Decl *Declaration,
+                          const struct Symbol &Symbol,
+                          CharSourceRange Range);
+
+  bool operator< (const DeclWithSymbolWithRange &Right) const;
+
+  bool operator== (const DeclWithSymbolWithRange &Right) const;
+};
+
+template<typename T>
+using VectorOfExpected = std::vector<llvm::Expected<T>>;
+
+using DeclsWithRangesOrErrors = VectorOfExpected<DeclWithRange>;
+
+using DeclsWithSymbolsWithRangesOrErrors =
+  VectorOfExpected<DeclWithSymbolWithRange>;
+
+template<typename T>
+VectorOfExpected<T> wrapInVector(T &);
+template<typename T>
+VectorOfExpected<T> wrapInVector(T &&);
+template<typename T>
+VectorOfExpected<T> wrapInVector(llvm::Error &&);
+
+struct IndexedDeclWithSymbolWithRange {
   int Index;
-  SymbolWithRange SymbolWithRange;
+  Decl *Declaration;
+  Symbol Symbol;
+  CharSourceRange Range;
 
   /// @brief Trivial memberwise-like constructor
-  IndexedSymbolWithRange(const int Index,
-                         const struct SymbolWithRange &SymbolWithRange);
+  IndexedDeclWithSymbolWithRange(const int Index,
+                                 const DeclWithSymbolWithRange &DeclAndSymbolAndRange);
 
   /// @brief Comparison required for containing IndexedSymbolWithRange in sets.
   /// It's taking only symbol into consideration, not range nor index.
   struct SymbolCompare {
-    bool operator() (const IndexedSymbolWithRange& Left,
-                     const IndexedSymbolWithRange& Right) const;
+    bool operator() (const IndexedDeclWithSymbolWithRange& Left,
+                     const IndexedDeclWithSymbolWithRange& Right) const;
   };
 
   /// @brief Comparison required for containing IndexedSymbolWithRange in sets.
   /// It's taking only symbol with range into consideration, not index.
   struct SymbolWithRangeCompare {
-    bool operator() (const IndexedSymbolWithRange& Left,
-                     const IndexedSymbolWithRange& Right) const;
+    bool operator() (const IndexedDeclWithSymbolWithRange& Left,
+                     const IndexedDeclWithSymbolWithRange& Right) const;
   };
 };
 
 using SingleSymbolOrError = llvm::Expected<Symbol>;
 
 using SymbolsOrError = llvm::Expected<std::vector<SymbolWithRange>>;
 
-using GlobalCollectedSymbols = std::set<IndexedSymbolWithRange,
-                                IndexedSymbolWithRange::SymbolWithRangeCompare>;
+using GlobalCollectedSymbols = std::set<IndexedDeclWithSymbolWithRange, IndexedDeclWithSymbolWithRange::SymbolWithRangeCompare>;
 } //namespace obfuscation
 } //namespace swift