1 //===--- Extract.cpp - Clang refactoring library --------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// 9 /// \file 10 /// Implements the "extract" refactoring that can pull code into 11 /// new functions, methods or declare new variables. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #include "clang/Tooling/Refactoring/Extract/Extract.h" 16 #include "clang/AST/ASTContext.h" 17 #include "clang/AST/DeclCXX.h" 18 #include "clang/AST/Expr.h" 19 #include "clang/AST/ExprObjC.h" 20 #include "clang/Rewrite/Core/Rewriter.h" 21 #include "clang/Tooling/Refactoring/Extract/SourceExtraction.h" 22 23 namespace clang { 24 namespace tooling { 25 26 namespace { 27 28 /// Returns true if \c E is a simple literal or a reference expression that 29 /// should not be extracted. 30 bool isSimpleExpression(const Expr *E) { 31 if (!E) 32 return false; 33 switch (E->IgnoreParenCasts()->getStmtClass()) { 34 case Stmt::DeclRefExprClass: 35 case Stmt::PredefinedExprClass: 36 case Stmt::IntegerLiteralClass: 37 case Stmt::FloatingLiteralClass: 38 case Stmt::ImaginaryLiteralClass: 39 case Stmt::CharacterLiteralClass: 40 case Stmt::StringLiteralClass: 41 return true; 42 default: 43 return false; 44 } 45 } 46 47 SourceLocation computeFunctionExtractionLocation(const Decl *D) { 48 if (isa<CXXMethodDecl>(D)) { 49 // Code from method that is defined in class body should be extracted to a 50 // function defined just before the class. 51 while (const auto *RD = dyn_cast<CXXRecordDecl>(D->getLexicalDeclContext())) 52 D = RD; 53 } 54 return D->getBeginLoc(); 55 } 56 57 } // end anonymous namespace 58 59 const RefactoringDescriptor &ExtractFunction::describe() { 60 static const RefactoringDescriptor Descriptor = { 61 "extract-function", 62 "Extract Function", 63 "(WIP action; use with caution!) Extracts code into a new function", 64 }; 65 return Descriptor; 66 } 67 68 Expected<ExtractFunction> 69 ExtractFunction::initiate(RefactoringRuleContext &Context, 70 CodeRangeASTSelection Code, 71 Optional<std::string> DeclName) { 72 // We would like to extract code out of functions/methods/blocks. 73 // Prohibit extraction from things like global variable / field 74 // initializers and other top-level expressions. 75 if (!Code.isInFunctionLikeBodyOfCode()) 76 return Context.createDiagnosticError( 77 diag::err_refactor_code_outside_of_function); 78 79 if (Code.size() == 1) { 80 // Avoid extraction of simple literals and references. 81 if (isSimpleExpression(dyn_cast<Expr>(Code[0]))) 82 return Context.createDiagnosticError( 83 diag::err_refactor_extract_simple_expression); 84 85 // Property setters can't be extracted. 86 if (const auto *PRE = dyn_cast<ObjCPropertyRefExpr>(Code[0])) { 87 if (!PRE->isMessagingGetter()) 88 return Context.createDiagnosticError( 89 diag::err_refactor_extract_prohibited_expression); 90 } 91 } 92 93 return ExtractFunction(std::move(Code), DeclName); 94 } 95 96 // FIXME: Support C++ method extraction. 97 // FIXME: Support Objective-C method extraction. 98 Expected<AtomicChanges> 99 ExtractFunction::createSourceReplacements(RefactoringRuleContext &Context) { 100 const Decl *ParentDecl = Code.getFunctionLikeNearestParent(); 101 assert(ParentDecl && "missing parent"); 102 103 // Compute the source range of the code that should be extracted. 104 SourceRange ExtractedRange(Code[0]->getBeginLoc(), 105 Code[Code.size() - 1]->getEndLoc()); 106 // FIXME (Alex L): Add code that accounts for macro locations. 107 108 ASTContext &AST = Context.getASTContext(); 109 SourceManager &SM = AST.getSourceManager(); 110 const LangOptions &LangOpts = AST.getLangOpts(); 111 Rewriter ExtractedCodeRewriter(SM, LangOpts); 112 113 // FIXME: Capture used variables. 114 115 // Compute the return type. 116 QualType ReturnType = AST.VoidTy; 117 // FIXME (Alex L): Account for the return statement in extracted code. 118 // FIXME (Alex L): Check for lexical expression instead. 119 bool IsExpr = Code.size() == 1 && isa<Expr>(Code[0]); 120 if (IsExpr) { 121 // FIXME (Alex L): Get a more user-friendly type if needed. 122 ReturnType = cast<Expr>(Code[0])->getType(); 123 } 124 125 // FIXME: Rewrite the extracted code performing any required adjustments. 126 127 // FIXME: Capture any field if necessary (method -> function extraction). 128 129 // FIXME: Sort captured variables by name. 130 131 // FIXME: Capture 'this' / 'self' if necessary. 132 133 // FIXME: Compute the actual parameter types. 134 135 // Compute the location of the extracted declaration. 136 SourceLocation ExtractedDeclLocation = 137 computeFunctionExtractionLocation(ParentDecl); 138 // FIXME: Adjust the location to account for any preceding comments. 139 140 // FIXME: Adjust with PP awareness like in Sema to get correct 'bool' 141 // treatment. 142 PrintingPolicy PP = AST.getPrintingPolicy(); 143 // FIXME: PP.UseStdFunctionForLambda = true; 144 PP.SuppressStrongLifetime = true; 145 PP.SuppressLifetimeQualifiers = true; 146 PP.SuppressUnwrittenScope = true; 147 148 ExtractionSemicolonPolicy Semicolons = ExtractionSemicolonPolicy::compute( 149 Code[Code.size() - 1], ExtractedRange, SM, LangOpts); 150 AtomicChange Change(SM, ExtractedDeclLocation); 151 // Create the replacement for the extracted declaration. 152 { 153 std::string ExtractedCode; 154 llvm::raw_string_ostream OS(ExtractedCode); 155 // FIXME: Use 'inline' in header. 156 OS << "static "; 157 ReturnType.print(OS, PP, DeclName); 158 OS << '('; 159 // FIXME: Arguments. 160 OS << ')'; 161 162 // Function body. 163 OS << " {\n"; 164 if (IsExpr && !ReturnType->isVoidType()) 165 OS << "return "; 166 OS << ExtractedCodeRewriter.getRewrittenText(ExtractedRange); 167 if (Semicolons.isNeededInExtractedFunction()) 168 OS << ';'; 169 OS << "\n}\n\n"; 170 auto Err = Change.insert(SM, ExtractedDeclLocation, OS.str()); 171 if (Err) 172 return std::move(Err); 173 } 174 175 // Create the replacement for the call to the extracted declaration. 176 { 177 std::string ReplacedCode; 178 llvm::raw_string_ostream OS(ReplacedCode); 179 180 OS << DeclName << '('; 181 // FIXME: Forward arguments. 182 OS << ')'; 183 if (Semicolons.isNeededInOriginalFunction()) 184 OS << ';'; 185 186 auto Err = Change.replace( 187 SM, CharSourceRange::getTokenRange(ExtractedRange), OS.str()); 188 if (Err) 189 return std::move(Err); 190 } 191 192 // FIXME: Add support for assocciated symbol location to AtomicChange to mark 193 // the ranges of the name of the extracted declaration. 194 return AtomicChanges{std::move(Change)}; 195 } 196 197 } // end namespace tooling 198 } // end namespace clang 199