Refractor parser to reduce loc by moving to header

Author: devajithvs

mlir/lib/Tools/mlir-query/Matcher/Parser.cpp

@@ -247,18 +247,6 @@ class Parser::CodeTokenizer {
   const char *codeCompletionLocation = nullptr;
 };
 
-Parser::Sema::~Sema() = default;
-
-std::vector<ArgKind> Parser::Sema::getAcceptedCompletionTypes(
-    llvm::ArrayRef<std::pair<MatcherCtor, unsigned>> context) {
-  return {};
-}
-
-std::vector<MatcherCompletion>
-Parser::Sema::getMatcherCompletions(llvm::ArrayRef<ArgKind> acceptedTypes) {
-  return {};
-}
-
 // Entry for the scope of a parser
 struct Parser::ScopedContextEntry {
   Parser *parser;
@@ -568,40 +556,6 @@ Parser::Parser(CodeTokenizer *tokenizer, Sema *sema,
     : tokenizer(tokenizer), sema(sema ? sema : &*defaultRegistrySema),
       namedValues(namedValues), error(error) {}
 
-Parser::RegistrySema::~RegistrySema() = default;
-
-std::optional<MatcherCtor>
-Parser::RegistrySema::lookupMatcherCtor(llvm::StringRef matcherName) {
-  return Registry::lookupMatcherCtor(matcherName);
-}
-
-VariantMatcher Parser::RegistrySema::actOnMatcherExpression(
-    MatcherCtor ctor, SourceRange nameRange, ArrayRef<ParserValue> args,
-    Diagnostics *error) {
-  return Registry::constructMatcher(ctor, nameRange, args, error);
-}
-
-std::vector<ArgKind> Parser::RegistrySema::getAcceptedCompletionTypes(
-    ArrayRef<std::pair<MatcherCtor, unsigned>> context) {
-  return Registry::getAcceptedCompletionTypes(context);
-}
-
-std::vector<MatcherCompletion>
-Parser::RegistrySema::getMatcherCompletions(ArrayRef<ArgKind> acceptedTypes) {
-  return Registry::getMatcherCompletions(acceptedTypes);
-}
-
-bool Parser::RegistrySema::isBuilderMatcher(MatcherCtor ctor) const {
-  return Registry::isBuilderMatcher(ctor);
-}
-
-internal::MatcherDescriptorPtr
-Parser::RegistrySema::buildMatcherCtor(MatcherCtor ctor, SourceRange nameRange,
-                                       ArrayRef<ParserValue> args,
-                                       Diagnostics *error) const {
-  return Registry::buildMatcherCtor(ctor, nameRange, args, error);
-}
-
 bool Parser::parseExpression(llvm::StringRef &code, Sema *sema,
                              const NamedValueMap *namedValues,
                              VariantValue *value, Diagnostics *error) {

mlir/lib/Tools/mlir-query/Matcher/Parser.h

@@ -45,7 +45,7 @@ class Parser {
   // matcher tokens.
   class Sema {
   public:
-    virtual ~Sema();
+    virtual ~Sema() = default;
 
     // Process a matcher expression. The caller takes ownership of the Matcher
     // object returned.
@@ -58,47 +58,51 @@ class Parser {
     virtual std::optional<MatcherCtor>
     lookupMatcherCtor(llvm::StringRef matcherName) = 0;
 
-    virtual bool isBuilderMatcher(MatcherCtor) const = 0;
+    virtual bool isBuilderMatcher(MatcherCtor ctor) const = 0;
 
     virtual internal::MatcherDescriptorPtr
-    buildMatcherCtor(MatcherCtor, SourceRange nameRange,
+    buildMatcherCtor(MatcherCtor ctor, SourceRange nameRange,
                      ArrayRef<ParserValue> args, Diagnostics *error) const = 0;
 
-    // Compute the list of completion types for Context.
     virtual std::vector<ArgKind> getAcceptedCompletionTypes(
-        llvm::ArrayRef<std::pair<MatcherCtor, unsigned>> Context);
+        llvm::ArrayRef<std::pair<MatcherCtor, unsigned>> context) {
+      return {};
+    }
 
-    // Compute the list of completions that match any of acceptedTypes.
     virtual std::vector<MatcherCompletion>
-    getMatcherCompletions(llvm::ArrayRef<ArgKind> acceptedTypes);
+    getMatcherCompletions(llvm::ArrayRef<ArgKind> acceptedTypes) {
+      return {};
+    }
   };
 
   // RegistrySema class - an implementation of the Sema interface that uses the
   // matcher registry to process tokens.
   class RegistrySema : public Parser::Sema {
   public:
-    ~RegistrySema() override;
+    ~RegistrySema() override = default;
 
     std::optional<MatcherCtor>
-    lookupMatcherCtor(llvm::StringRef matcherName) override;
+    lookupMatcherCtor(llvm::StringRef matcherName) override {
+      return Registry::lookupMatcherCtor(matcherName);
+    }
 
     VariantMatcher actOnMatcherExpression(MatcherCtor ctor,
                                           SourceRange nameRange,
                                           ArrayRef<ParserValue> args,
-                                          Diagnostics *error) override;
+                                          Diagnostics *error) override {
+      return Registry::constructMatcher(ctor, nameRange, args, error);
+    }
 
-    bool isBuilderMatcher(MatcherCtor ctor) const override;
-
-    std::vector<ArgKind> getAcceptedCompletionTypes(
-        llvm::ArrayRef<std::pair<MatcherCtor, unsigned>> context) override;
+    bool isBuilderMatcher(MatcherCtor ctor) const override {
+      return Registry::isBuilderMatcher(ctor);
+    }
 
     internal::MatcherDescriptorPtr
-    buildMatcherCtor(MatcherCtor, SourceRange nameRange,
+    buildMatcherCtor(MatcherCtor ctor, SourceRange nameRange,
                      ArrayRef<ParserValue> args,
-                     Diagnostics *error) const override;
-
-    std::vector<MatcherCompletion>
-    getMatcherCompletions(llvm::ArrayRef<ArgKind> acceptedTypes) override;
+                     Diagnostics *error) const override {
+      return Registry::buildMatcherCtor(ctor, nameRange, args, error);
+    }
   };
 
   using NamedValueMap = llvm::StringMap<VariantValue>;
@@ -108,17 +112,18 @@ class Parser {
   static std::optional<DynMatcher>
   parseMatcherExpression(llvm::StringRef &matcherCode, Sema *sema,
                          const NamedValueMap *namedValues, Diagnostics *error);
+
   static std::optional<DynMatcher>
   parseMatcherExpression(llvm::StringRef &matcherCode, Sema *sema,
                          Diagnostics *error) {
     return parseMatcherExpression(matcherCode, sema, nullptr, error);
   }
+
   static std::optional<DynMatcher>
   parseMatcherExpression(llvm::StringRef &matcherCode, Diagnostics *error) {
     return parseMatcherExpression(matcherCode, nullptr, error);
   }
 
-  // Methods to parse any expression supported by this parser.
   static bool parseExpression(llvm::StringRef &code, Sema *sema,
                               const NamedValueMap *namedValues,
                               VariantValue *value, Diagnostics *error);
@@ -127,20 +132,22 @@ class Parser {
                               VariantValue *value, Diagnostics *error) {
     return parseExpression(code, sema, nullptr, value, error);
   }
+
   static bool parseExpression(llvm::StringRef &code, VariantValue *value,
                               Diagnostics *error) {
     return parseExpression(code, nullptr, value, error);
   }
 
-  // Methods to complete an expression at a given offset.
   static std::vector<MatcherCompletion>
   completeExpression(llvm::StringRef &code, unsigned completionOffset,
                      Sema *sema, const NamedValueMap *namedValues);
+
   static std::vector<MatcherCompletion>
   completeExpression(llvm::StringRef &code, unsigned completionOffset,
                      Sema *sema) {
     return completeExpression(code, completionOffset, sema, nullptr);
   }
+
   static std::vector<MatcherCompletion>
   completeExpression(llvm::StringRef &code, unsigned completionOffset) {
     return completeExpression(code, completionOffset, nullptr);
@@ -160,11 +167,14 @@ class Parser {
                                const TokenInfo &nameToken,
                                const TokenInfo &openToken,
                                const TokenInfo &endToken, VariantValue *value);
+
   bool parseMatcherArgs(bool isBuilder, std::vector<ParserValue> &args,
                         MatcherCtor ctor, const TokenInfo &nameToken,
                         TokenInfo &endToken);
+
   bool parseMatcherBuilder(MatcherCtor ctor, const TokenInfo &nameToken,
                            const TokenInfo &openToken, VariantValue *value);
+
   bool parseMatcherExpressionImpl(const TokenInfo &nameToken,
                                   const TokenInfo &openToken,
                                   std::optional<MatcherCtor> ctor,
@@ -174,6 +184,7 @@ class Parser {
 
   void addCompletion(const TokenInfo &compToken,
                      const MatcherCompletion &completion);
+
   void addExpressionCompletions();
 
   std::vector<MatcherCompletion>
@@ -185,7 +196,6 @@ class Parser {
   Diagnostics *const error;
 
   using ContextStackTy = std::vector<std::pair<MatcherCtor, unsigned>>;
-
   ContextStackTy contextStack;
   std::vector<MatcherCompletion> completions;
 };