1	//===--- ObjCMT.cpp - ObjC Migrate Tool -----------------------------------===//
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	#include "Transforms.h"
10	#include "clang/Analysis/RetainSummaryManager.h"
11	#include "clang/ARCMigrate/ARCMT.h"
12	#include "clang/ARCMigrate/ARCMTActions.h"
13	#include "clang/AST/ASTConsumer.h"
14	#include "clang/AST/ASTContext.h"
15	#include "clang/AST/Attr.h"
16	#include "clang/AST/NSAPI.h"
17	#include "clang/AST/ParentMap.h"
18	#include "clang/AST/RecursiveASTVisitor.h"
19	#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
20	#include "clang/Basic/FileManager.h"
21	#include "clang/Edit/Commit.h"
22	#include "clang/Edit/EditedSource.h"
23	#include "clang/Edit/EditsReceiver.h"
24	#include "clang/Edit/Rewriters.h"
25	#include "clang/Frontend/CompilerInstance.h"
26	#include "clang/Frontend/MultiplexConsumer.h"
27	#include "clang/Lex/PPConditionalDirectiveRecord.h"
28	#include "clang/Lex/Preprocessor.h"
29	#include "clang/Rewrite/Core/Rewriter.h"
30	#include "llvm/ADT/SmallString.h"
31	#include "llvm/ADT/StringSet.h"
32	#include "llvm/Support/Path.h"
33	#include "llvm/Support/SourceMgr.h"
34	#include "llvm/Support/YAMLParser.h"
35
36	using namespace clang;
37	using namespace arcmt;
38	using namespace ento;
39
40	namespace {
41
42	class ObjCMigrateASTConsumer : public ASTConsumer {
43	enum CF_BRIDGING_KIND {
44	CF_BRIDGING_NONE,
45	CF_BRIDGING_ENABLE,
46	CF_BRIDGING_MAY_INCLUDE
47	};
48
49	void migrateDecl(Decl *D);
50	void migrateObjCContainerDecl(ASTContext &Ctx, ObjCContainerDecl *D);
51	void migrateProtocolConformance(ASTContext &Ctx,
52	const ObjCImplementationDecl *ImpDecl);
53	void CacheObjCNSIntegerTypedefed(const TypedefDecl *TypedefDcl);
54	bool migrateNSEnumDecl(ASTContext &Ctx, const EnumDecl *EnumDcl,
55	const TypedefDecl *TypedefDcl);
56	void migrateAllMethodInstaceType(ASTContext &Ctx, ObjCContainerDecl *CDecl);
57	void migrateMethodInstanceType(ASTContext &Ctx, ObjCContainerDecl *CDecl,
58	ObjCMethodDecl *OM);
59	bool migrateProperty(ASTContext &Ctx, ObjCContainerDecl *D, ObjCMethodDecl *OM);
60	void migrateNsReturnsInnerPointer(ASTContext &Ctx, ObjCMethodDecl *OM);
61	void migratePropertyNsReturnsInnerPointer(ASTContext &Ctx, ObjCPropertyDecl *P);
62	void migrateFactoryMethod(ASTContext &Ctx, ObjCContainerDecl *CDecl,
63	ObjCMethodDecl *OM,
64	ObjCInstanceTypeFamily OIT_Family = OIT_None);
65
66	void migrateCFAnnotation(ASTContext &Ctx, const Decl *Decl);
67	void AddCFAnnotations(ASTContext &Ctx,
68	const RetainSummary *RS,
69	const FunctionDecl *FuncDecl, bool ResultAnnotated);
70	void AddCFAnnotations(ASTContext &Ctx,
71	const RetainSummary *RS,
72	const ObjCMethodDecl *MethodDecl, bool ResultAnnotated);
73
74	void AnnotateImplicitBridging(ASTContext &Ctx);
75
76	CF_BRIDGING_KIND migrateAddFunctionAnnotation(ASTContext &Ctx,
77	const FunctionDecl *FuncDecl);
78
79	void migrateARCSafeAnnotation(ASTContext &Ctx, ObjCContainerDecl *CDecl);
80
81	void migrateAddMethodAnnotation(ASTContext &Ctx,
82	const ObjCMethodDecl *MethodDecl);
83
84	void inferDesignatedInitializers(ASTContext &Ctx,
85	const ObjCImplementationDecl *ImplD);
86
87	bool InsertFoundation(ASTContext &Ctx, SourceLocation Loc);
88
89	std::unique_ptr<RetainSummaryManager> Summaries;
90
91	public:
92	std::string MigrateDir;
93	unsigned ASTMigrateActions;
94	FileID FileId;
95	const TypedefDecl *NSIntegerTypedefed;
96	const TypedefDecl *NSUIntegerTypedefed;
97	std::unique_ptr<NSAPI> NSAPIObj;
98	std::unique_ptr<edit::EditedSource> Editor;
99	FileRemapper &Remapper;
100	FileManager &FileMgr;
101	const PPConditionalDirectiveRecord *PPRec;
102	Preprocessor &PP;
103	bool IsOutputFile;
104	bool FoundationIncluded;
105	llvm::SmallPtrSet<ObjCProtocolDecl *, 32> ObjCProtocolDecls;
106	llvm::SmallVector<const Decl *, 8> CFFunctionIBCandidates;
107	llvm::StringSet<> AllowListFilenames;
108
109	RetainSummaryManager &getSummaryManager(ASTContext &Ctx) {
110	if (!Summaries)
111	Summaries.reset(p: new RetainSummaryManager(Ctx,
112	/*TrackNSCFObjects=*/true,
113	/*trackOSObjects=*/false));
114	return *Summaries;
115	}
116
117	ObjCMigrateASTConsumer(StringRef migrateDir, unsigned astMigrateActions,
118	FileRemapper &remapper, FileManager &fileMgr,
119	const PPConditionalDirectiveRecord *PPRec,
120	Preprocessor &PP, bool isOutputFile,
121	ArrayRef<std::string> AllowList)
122	: MigrateDir(migrateDir), ASTMigrateActions(astMigrateActions),
123	NSIntegerTypedefed(nullptr), NSUIntegerTypedefed(nullptr),
124	Remapper(remapper), FileMgr(fileMgr), PPRec(PPRec), PP(PP),
125	IsOutputFile(isOutputFile), FoundationIncluded(false) {
126	AllowListFilenames.insert(begin: AllowList.begin(), end: AllowList.end());
127	}
128
129	protected:
130	void Initialize(ASTContext &Context) override {
131	NSAPIObj.reset(p: new NSAPI(Context));
132	Editor.reset(p: new edit::EditedSource(Context.getSourceManager(),
133	Context.getLangOpts(),
134	PPRec));
135	}
136
137	bool HandleTopLevelDecl(DeclGroupRef DG) override {
138	for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
139	migrateDecl(D: *I);
140	return true;
141	}
142	void HandleInterestingDecl(DeclGroupRef DG) override {
143	// Ignore decls from the PCH.
144	}
145	void HandleTopLevelDeclInObjCContainer(DeclGroupRef DG) override {
146	ObjCMigrateASTConsumer::HandleTopLevelDecl(DG);
147	}
148
149	void HandleTranslationUnit(ASTContext &Ctx) override;
150
151	bool canModifyFile(StringRef Path) {
152	if (AllowListFilenames.empty())
153	return true;
154	return AllowListFilenames.contains(key: llvm::sys::path::filename(path: Path));
155	}
156	bool canModifyFile(OptionalFileEntryRef FE) {
157	if (!FE)
158	return false;
159	return canModifyFile(Path: FE->getName());
160	}
161	bool canModifyFile(FileID FID) {
162	if (FID.isInvalid())
163	return false;
164	return canModifyFile(FE: PP.getSourceManager().getFileEntryRefForID(FID));
165	}
166
167	bool canModify(const Decl *D) {
168	if (!D)
169	return false;
170	if (const ObjCCategoryImplDecl *CatImpl = dyn_cast<ObjCCategoryImplDecl>(Val: D))
171	return canModify(CatImpl->getCategoryDecl());
172	if (const ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(Val: D))
173	return canModify(D: Impl->getClassInterface());
174	if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(Val: D))
175	return canModify(D: cast<Decl>(MD->getDeclContext()));
176
177	FileID FID = PP.getSourceManager().getFileID(SpellingLoc: D->getLocation());
178	return canModifyFile(FID);
179	}
180	};
181
182	} // end anonymous namespace
183
184	ObjCMigrateAction::ObjCMigrateAction(
185	std::unique_ptr<FrontendAction> WrappedAction, StringRef migrateDir,
186	unsigned migrateAction)
187	: WrapperFrontendAction(std::move(WrappedAction)), MigrateDir(migrateDir),
188	ObjCMigAction(migrateAction), CompInst(nullptr) {
189	if (MigrateDir.empty())
190	MigrateDir = "."; // user current directory if none is given.
191	}
192
193	std::unique_ptr<ASTConsumer>
194	ObjCMigrateAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
195	PPConditionalDirectiveRecord *
196	PPRec = new PPConditionalDirectiveRecord(CompInst->getSourceManager());
197	CI.getPreprocessor().addPPCallbacks(C: std::unique_ptr<PPCallbacks>(PPRec));
198	std::vector<std::unique_ptr<ASTConsumer>> Consumers;
199	Consumers.push_back(x: WrapperFrontendAction::CreateASTConsumer(CI, InFile));
200	Consumers.push_back(x: std::make_unique<ObjCMigrateASTConsumer>(
201	args&: MigrateDir, args&: ObjCMigAction, args&: Remapper, args&: CompInst->getFileManager(), args&: PPRec,
202	args&: CompInst->getPreprocessor(), args: false, args: std::nullopt));
203	return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
204	}
205
206	bool ObjCMigrateAction::BeginInvocation(CompilerInstance &CI) {
207	Remapper.initFromDisk(outputDir: MigrateDir, Diag&: CI.getDiagnostics(),
208	/*ignoreIfFilesChanged=*/true);
209	CompInst = &CI;
210	CI.getDiagnostics().setIgnoreAllWarnings(true);
211	return true;
212	}
213
214	namespace {
215	// FIXME. This duplicates one in RewriteObjCFoundationAPI.cpp
216	bool subscriptOperatorNeedsParens(const Expr *FullExpr) {
217	const Expr* Expr = FullExpr->IgnoreImpCasts();
218	return !(isa<ArraySubscriptExpr>(Val: Expr) || isa<CallExpr>(Val: Expr) ||
219	isa<DeclRefExpr>(Val: Expr) || isa<CXXNamedCastExpr>(Val: Expr) ||
220	isa<CXXConstructExpr>(Val: Expr) || isa<CXXThisExpr>(Val: Expr) ||
221	isa<CXXTypeidExpr>(Val: Expr) ||
222	isa<CXXUnresolvedConstructExpr>(Val: Expr) ||
223	isa<ObjCMessageExpr>(Val: Expr) || isa<ObjCPropertyRefExpr>(Val: Expr) ||
224	isa<ObjCProtocolExpr>(Val: Expr) || isa<MemberExpr>(Val: Expr) ||
225	isa<ObjCIvarRefExpr>(Val: Expr) || isa<ParenExpr>(Val: FullExpr) ||
226	isa<ParenListExpr>(Val: Expr) || isa<SizeOfPackExpr>(Val: Expr));
227	}
228
229	/// - Rewrite message expression for Objective-C setter and getters into
230	/// property-dot syntax.
231	bool rewriteToPropertyDotSyntax(const ObjCMessageExpr *Msg,
232	Preprocessor &PP,
233	const NSAPI &NS, edit::Commit &commit,
234	const ParentMap *PMap) {
235	if (!Msg || Msg->isImplicit() ||
236	(Msg->getReceiverKind() != ObjCMessageExpr::Instance &&
237	Msg->getReceiverKind() != ObjCMessageExpr::SuperInstance))
238	return false;
239	if (const Expr *Receiver = Msg->getInstanceReceiver())
240	if (Receiver->getType()->isObjCBuiltinType())
241	return false;
242
243	const ObjCMethodDecl *Method = Msg->getMethodDecl();
244	if (!Method)
245	return false;
246	if (!Method->isPropertyAccessor())
247	return false;
248
249	const ObjCPropertyDecl *Prop = Method->findPropertyDecl();
250	if (!Prop)
251	return false;
252
253	SourceRange MsgRange = Msg->getSourceRange();
254	bool ReceiverIsSuper =
255	(Msg->getReceiverKind() == ObjCMessageExpr::SuperInstance);
256	// for 'super' receiver is nullptr.
257	const Expr *receiver = Msg->getInstanceReceiver();
258	bool NeedsParen =
259	ReceiverIsSuper ? false : subscriptOperatorNeedsParens(FullExpr: receiver);
260	bool IsGetter = (Msg->getNumArgs() == 0);
261	if (IsGetter) {
262	// Find space location range between receiver expression and getter method.
263	SourceLocation BegLoc =
264	ReceiverIsSuper ? Msg->getSuperLoc() : receiver->getEndLoc();
265	BegLoc = PP.getLocForEndOfToken(Loc: BegLoc);
266	SourceLocation EndLoc = Msg->getSelectorLoc(Index: 0);
267	SourceRange SpaceRange(BegLoc, EndLoc);
268	std::string PropertyDotString;
269	// rewrite getter method expression into: receiver.property or
270	// (receiver).property
271	if (NeedsParen) {
272	commit.insertBefore(loc: receiver->getBeginLoc(), text: "(");
273	PropertyDotString = ").";
274	}
275	else
276	PropertyDotString = ".";
277	PropertyDotString += Prop->getName();
278	commit.replace(TokenRange: SpaceRange, text: PropertyDotString);
279
280	// remove '[' ']'
281	commit.replace(TokenRange: SourceRange(MsgRange.getBegin(), MsgRange.getBegin()), text: "");
282	commit.replace(TokenRange: SourceRange(MsgRange.getEnd(), MsgRange.getEnd()), text: "");
283	} else {
284	if (NeedsParen)
285	commit.insertWrap("(", receiver->getSourceRange(), ")");
286	std::string PropertyDotString = ".";
287	PropertyDotString += Prop->getName();
288	PropertyDotString += " =";
289	const Expr*const* Args = Msg->getArgs();
290	const Expr *RHS = Args[0];
291	if (!RHS)
292	return false;
293	SourceLocation BegLoc =
294	ReceiverIsSuper ? Msg->getSuperLoc() : receiver->getEndLoc();
295	BegLoc = PP.getLocForEndOfToken(Loc: BegLoc);
296	SourceLocation EndLoc = RHS->getBeginLoc();
297	EndLoc = EndLoc.getLocWithOffset(Offset: -1);
298	const char *colon = PP.getSourceManager().getCharacterData(SL: EndLoc);
299	// Add a space after '=' if there is no space between RHS and '='
300	if (colon && colon[0] == ':')
301	PropertyDotString += " ";
302	SourceRange Range(BegLoc, EndLoc);
303	commit.replace(TokenRange: Range, text: PropertyDotString);
304	// remove '[' ']'
305	commit.replace(TokenRange: SourceRange(MsgRange.getBegin(), MsgRange.getBegin()), text: "");
306	commit.replace(TokenRange: SourceRange(MsgRange.getEnd(), MsgRange.getEnd()), text: "");
307	}
308	return true;
309	}
310
311	class ObjCMigrator : public RecursiveASTVisitor<ObjCMigrator> {
312	ObjCMigrateASTConsumer &Consumer;
313	ParentMap &PMap;
314
315	public:
316	ObjCMigrator(ObjCMigrateASTConsumer &consumer, ParentMap &PMap)
317	: Consumer(consumer), PMap(PMap) { }
318
319	bool shouldVisitTemplateInstantiations() const { return false; }
320	bool shouldWalkTypesOfTypeLocs() const { return false; }
321
322	bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
323	if (Consumer.ASTMigrateActions & FrontendOptions::ObjCMT_Literals) {
324	edit::Commit commit(*Consumer.Editor);
325	edit::rewriteToObjCLiteralSyntax(Msg: E, NS: *Consumer.NSAPIObj, commit, PMap: &PMap);
326	Consumer.Editor->commit(commit);
327	}
328
329	if (Consumer.ASTMigrateActions & FrontendOptions::ObjCMT_Subscripting) {
330	edit::Commit commit(*Consumer.Editor);
331	edit::rewriteToObjCSubscriptSyntax(Msg: E, NS: *Consumer.NSAPIObj, commit);
332	Consumer.Editor->commit(commit);
333	}
334
335	if (Consumer.ASTMigrateActions & FrontendOptions::ObjCMT_PropertyDotSyntax) {
336	edit::Commit commit(*Consumer.Editor);
337	rewriteToPropertyDotSyntax(Msg: E, PP&: Consumer.PP, NS: *Consumer.NSAPIObj,
338	commit, PMap: &PMap);
339	Consumer.Editor->commit(commit);
340	}
341
342	return true;
343	}
344
345	bool TraverseObjCMessageExpr(ObjCMessageExpr *E) {
346	// Do depth first; we want to rewrite the subexpressions first so that if
347	// we have to move expressions we will move them already rewritten.
348	for (Stmt *SubStmt : E->children())
349	if (!TraverseStmt(S: SubStmt))
350	return false;
351
352	return WalkUpFromObjCMessageExpr(E);
353	}
354	};
355
356	class BodyMigrator : public RecursiveASTVisitor<BodyMigrator> {
357	ObjCMigrateASTConsumer &Consumer;
358	std::unique_ptr<ParentMap> PMap;
359
360	public:
361	BodyMigrator(ObjCMigrateASTConsumer &consumer) : Consumer(consumer) { }
362
363	bool shouldVisitTemplateInstantiations() const { return false; }
364	bool shouldWalkTypesOfTypeLocs() const { return false; }
365
366	bool TraverseStmt(Stmt *S) {
367	PMap.reset(p: new ParentMap(S));
368	ObjCMigrator(Consumer, *PMap).TraverseStmt(S);
369	return true;
370	}
371	};
372	} // end anonymous namespace
373
374	void ObjCMigrateASTConsumer::migrateDecl(Decl *D) {
375	if (!D)
376	return;
377	if (isa<ObjCMethodDecl>(Val: D))
378	return; // Wait for the ObjC container declaration.
379
380	BodyMigrator(*this).TraverseDecl(D);
381	}
382
383	static void append_attr(std::string &PropertyString, const char *attr,
384	bool &LParenAdded) {
385	if (!LParenAdded) {
386	PropertyString += "(";
387	LParenAdded = true;
388	}
389	else
390	PropertyString += ", ";
391	PropertyString += attr;
392	}
393
394	static
395	void MigrateBlockOrFunctionPointerTypeVariable(std::string & PropertyString,
396	const std::string& TypeString,
397	const char *name) {
398	const char *argPtr = TypeString.c_str();
399	int paren = 0;
400	while (*argPtr) {
401	switch (*argPtr) {
402	case '(':
403	PropertyString += *argPtr;
404	paren++;
405	break;
406	case ')':
407	PropertyString += *argPtr;
408	paren--;
409	break;
410	case '^':
411	case '*':
412	PropertyString += (*argPtr);
413	if (paren == 1) {
414	PropertyString += name;
415	name = "";
416	}
417	break;
418	default:
419	PropertyString += *argPtr;
420	break;
421	}
422	argPtr++;
423	}
424	}
425
426	static const char *PropertyMemoryAttribute(ASTContext &Context, QualType ArgType) {
427	Qualifiers::ObjCLifetime propertyLifetime = ArgType.getObjCLifetime();
428	bool RetainableObject = ArgType->isObjCRetainableType();
429	if (RetainableObject &&
430	(propertyLifetime == Qualifiers::OCL_Strong
431	|| propertyLifetime == Qualifiers::OCL_None)) {
432	if (const ObjCObjectPointerType *ObjPtrTy =
433	ArgType->getAs<ObjCObjectPointerType>()) {
434	ObjCInterfaceDecl *IDecl = ObjPtrTy->getObjectType()->getInterface();
435	if (IDecl &&
436	IDecl->lookupNestedProtocol(Name: &Context.Idents.get(Name: "NSCopying")))
437	return "copy";
438	else
439	return "strong";
440	}
441	else if (ArgType->isBlockPointerType())
442	return "copy";
443	} else if (propertyLifetime == Qualifiers::OCL_Weak)
444	// TODO. More precise determination of 'weak' attribute requires
445	// looking into setter's implementation for backing weak ivar.
446	return "weak";
447	else if (RetainableObject)
448	return ArgType->isBlockPointerType() ? "copy" : "strong";
449	return nullptr;
450	}
451
452	static void rewriteToObjCProperty(const ObjCMethodDecl *Getter,
453	const ObjCMethodDecl *Setter,
454	const NSAPI &NS, edit::Commit &commit,
455	unsigned LengthOfPrefix,
456	bool Atomic, bool UseNsIosOnlyMacro,
457	bool AvailabilityArgsMatch) {
458	ASTContext &Context = NS.getASTContext();
459	bool LParenAdded = false;
460	std::string PropertyString = "@property ";
461	if (UseNsIosOnlyMacro && NS.isMacroDefined(Id: "NS_NONATOMIC_IOSONLY")) {
462	PropertyString += "(NS_NONATOMIC_IOSONLY";
463	LParenAdded = true;
464	} else if (!Atomic) {
465	PropertyString += "(nonatomic";
466	LParenAdded = true;
467	}
468
469	std::string PropertyNameString = Getter->getNameAsString();
470	StringRef PropertyName(PropertyNameString);
471	if (LengthOfPrefix > 0) {
472	if (!LParenAdded) {
473	PropertyString += "(getter=";
474	LParenAdded = true;
475	}
476	else
477	PropertyString += ", getter=";
478	PropertyString += PropertyNameString;
479	}
480	// Property with no setter may be suggested as a 'readonly' property.
481	if (!Setter)
482	append_attr(PropertyString, attr: "readonly", LParenAdded);
483
484
485	// Short circuit 'delegate' properties that contain the name "delegate" or
486	// "dataSource", or have exact name "target" to have 'assign' attribute.
487	if (PropertyName.equals(RHS: "target") || PropertyName.contains(Other: "delegate") ||
488	PropertyName.contains(Other: "dataSource")) {
489	QualType QT = Getter->getReturnType();
490	if (!QT->isRealType())
491	append_attr(PropertyString, attr: "assign", LParenAdded);
492	} else if (!Setter) {
493	QualType ResType = Context.getCanonicalType(T: Getter->getReturnType());
494	if (const char *MemoryManagementAttr = PropertyMemoryAttribute(Context, ArgType: ResType))
495	append_attr(PropertyString, attr: MemoryManagementAttr, LParenAdded);
496	} else {
497	const ParmVarDecl *argDecl = *Setter->param_begin();
498	QualType ArgType = Context.getCanonicalType(argDecl->getType());
499	if (const char *MemoryManagementAttr = PropertyMemoryAttribute(Context, ArgType))
500	append_attr(PropertyString, attr: MemoryManagementAttr, LParenAdded);
501	}
502	if (LParenAdded)
503	PropertyString += ')';
504	QualType RT = Getter->getReturnType();
505	if (!RT->getAs<TypedefType>()) {
506	// strip off any ARC lifetime qualifier.
507	QualType CanResultTy = Context.getCanonicalType(T: RT);
508	if (CanResultTy.getQualifiers().hasObjCLifetime()) {
509	Qualifiers Qs = CanResultTy.getQualifiers();
510	Qs.removeObjCLifetime();
511	RT = Context.getQualifiedType(T: CanResultTy.getUnqualifiedType(), Qs);
512	}
513	}
514	PropertyString += " ";
515	PrintingPolicy SubPolicy(Context.getPrintingPolicy());
516	SubPolicy.SuppressStrongLifetime = true;
517	SubPolicy.SuppressLifetimeQualifiers = true;
518	std::string TypeString = RT.getAsString(Policy: SubPolicy);
519	if (LengthOfPrefix > 0) {
520	// property name must strip off "is" and lower case the first character
521	// after that; e.g. isContinuous will become continuous.
522	StringRef PropertyNameStringRef(PropertyNameString);
523	PropertyNameStringRef = PropertyNameStringRef.drop_front(N: LengthOfPrefix);
524	PropertyNameString = std::string(PropertyNameStringRef);
525	bool NoLowering = (isUppercase(c: PropertyNameString[0]) &&
526	PropertyNameString.size() > 1 &&
527	isUppercase(c: PropertyNameString[1]));
528	if (!NoLowering)
529	PropertyNameString[0] = toLowercase(c: PropertyNameString[0]);
530	}
531	if (RT->isBlockPointerType() || RT->isFunctionPointerType())
532	MigrateBlockOrFunctionPointerTypeVariable(PropertyString,
533	TypeString,
534	name: PropertyNameString.c_str());
535	else {
536	char LastChar = TypeString[TypeString.size()-1];
537	PropertyString += TypeString;
538	if (LastChar != '*')
539	PropertyString += ' ';
540	PropertyString += PropertyNameString;
541	}
542	SourceLocation StartGetterSelectorLoc = Getter->getSelectorStartLoc();
543	Selector GetterSelector = Getter->getSelector();
544
545	SourceLocation EndGetterSelectorLoc =
546	StartGetterSelectorLoc.getLocWithOffset(Offset: GetterSelector.getNameForSlot(argIndex: 0).size());
547	commit.replace(range: CharSourceRange::getCharRange(B: Getter->getBeginLoc(),
548	E: EndGetterSelectorLoc),
549	text: PropertyString);
550	if (Setter && AvailabilityArgsMatch) {
551	SourceLocation EndLoc = Setter->getDeclaratorEndLoc();
552	// Get location past ';'
553	EndLoc = EndLoc.getLocWithOffset(Offset: 1);
554	SourceLocation BeginOfSetterDclLoc = Setter->getBeginLoc();
555	// FIXME. This assumes that setter decl; is immediately preceded by eoln.
556	// It is trying to remove the setter method decl. line entirely.
557	BeginOfSetterDclLoc = BeginOfSetterDclLoc.getLocWithOffset(Offset: -1);
558	commit.remove(TokenRange: SourceRange(BeginOfSetterDclLoc, EndLoc));
559	}
560	}
561
562	static bool IsCategoryNameWithDeprecatedSuffix(ObjCContainerDecl *D) {
563	if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(Val: D)) {
564	StringRef Name = CatDecl->getName();
565	return Name.ends_with(Suffix: "Deprecated");
566	}
567	return false;
568	}
569
570	void ObjCMigrateASTConsumer::migrateObjCContainerDecl(ASTContext &Ctx,
571	ObjCContainerDecl *D) {
572	if (D->isDeprecated() || IsCategoryNameWithDeprecatedSuffix(D))
573	return;
574
575	for (auto *Method : D->methods()) {
576	if (Method->isDeprecated())
577	continue;
578	bool PropertyInferred = migrateProperty(Ctx, D, OM: Method);
579	// If a property is inferred, do not attempt to attach NS_RETURNS_INNER_POINTER to
580	// the getter method as it ends up on the property itself which we don't want
581	// to do unless -objcmt-returns-innerpointer-property option is on.
582	if (!PropertyInferred ||
583	(ASTMigrateActions & FrontendOptions::ObjCMT_ReturnsInnerPointerProperty))
584	if (ASTMigrateActions & FrontendOptions::ObjCMT_Annotation)
585	migrateNsReturnsInnerPointer(Ctx, OM: Method);
586	}
587	if (!(ASTMigrateActions & FrontendOptions::ObjCMT_ReturnsInnerPointerProperty))
588	return;
589
590	for (auto *Prop : D->instance_properties()) {
591	if ((ASTMigrateActions & FrontendOptions::ObjCMT_Annotation) &&
592	!Prop->isDeprecated())
593	migratePropertyNsReturnsInnerPointer(Ctx, P: Prop);
594	}
595	}
596
597	static bool
598	ClassImplementsAllMethodsAndProperties(ASTContext &Ctx,
599	const ObjCImplementationDecl *ImpDecl,
600	const ObjCInterfaceDecl *IDecl,
601	ObjCProtocolDecl *Protocol) {
602	// In auto-synthesis, protocol properties are not synthesized. So,
603	// a conforming protocol must have its required properties declared
604	// in class interface.
605	bool HasAtleastOneRequiredProperty = false;
606	if (const ObjCProtocolDecl *PDecl = Protocol->getDefinition())
607	for (const auto *Property : PDecl->instance_properties()) {
608	if (Property->getPropertyImplementation() == ObjCPropertyDecl::Optional)
609	continue;
610	HasAtleastOneRequiredProperty = true;
611	DeclContext::lookup_result R = IDecl->lookup(Property->getDeclName());
612	if (R.empty()) {
613	// Relax the rule and look into class's implementation for a synthesize
614	// or dynamic declaration. Class is implementing a property coming from
615	// another protocol. This still makes the target protocol as conforming.
616	if (!ImpDecl->FindPropertyImplDecl(
617	Property->getDeclName().getAsIdentifierInfo(),
618	Property->getQueryKind()))
619	return false;
620	} else if (auto *ClassProperty = R.find_first<ObjCPropertyDecl>()) {
621	if ((ClassProperty->getPropertyAttributes() !=
622	Property->getPropertyAttributes()) ||
623	!Ctx.hasSameType(ClassProperty->getType(), Property->getType()))
624	return false;
625	} else
626	return false;
627	}
628
629	// At this point, all required properties in this protocol conform to those
630	// declared in the class.
631	// Check that class implements the required methods of the protocol too.
632	bool HasAtleastOneRequiredMethod = false;
633	if (const ObjCProtocolDecl *PDecl = Protocol->getDefinition()) {
634	if (PDecl->meth_begin() == PDecl->meth_end())
635	return HasAtleastOneRequiredProperty;
636	for (const auto *MD : PDecl->methods()) {
637	if (MD->isImplicit())
638	continue;
639	if (MD->getImplementationControl() == ObjCImplementationControl::Optional)
640	continue;
641	DeclContext::lookup_result R = ImpDecl->lookup(MD->getDeclName());
642	if (R.empty())
643	return false;
644	bool match = false;
645	HasAtleastOneRequiredMethod = true;
646	for (NamedDecl *ND : R)
647	if (ObjCMethodDecl *ImpMD = dyn_cast<ObjCMethodDecl>(ND))
648	if (Ctx.ObjCMethodsAreEqual(MD, ImpMD)) {
649	match = true;
650	break;
651	}
652	if (!match)
653	return false;
654	}
655	}
656	return HasAtleastOneRequiredProperty || HasAtleastOneRequiredMethod;
657	}
658
659	static bool rewriteToObjCInterfaceDecl(const ObjCInterfaceDecl *IDecl,
660	llvm::SmallVectorImpl<ObjCProtocolDecl*> &ConformingProtocols,
661	const NSAPI &NS, edit::Commit &commit) {
662	const ObjCList<ObjCProtocolDecl> &Protocols = IDecl->getReferencedProtocols();
663	std::string ClassString;
664	SourceLocation EndLoc =
665	IDecl->getSuperClass() ? IDecl->getSuperClassLoc() : IDecl->getLocation();
666
667	if (Protocols.empty()) {
668	ClassString = '<';
669	for (unsigned i = 0, e = ConformingProtocols.size(); i != e; i++) {
670	ClassString += ConformingProtocols[i]->getNameAsString();
671	if (i != (e-1))
672	ClassString += ", ";
673	}
674	ClassString += "> ";
675	}
676	else {
677	ClassString = ", ";
678	for (unsigned i = 0, e = ConformingProtocols.size(); i != e; i++) {
679	ClassString += ConformingProtocols[i]->getNameAsString();
680	if (i != (e-1))
681	ClassString += ", ";
682	}
683	ObjCInterfaceDecl::protocol_loc_iterator PL = IDecl->protocol_loc_end() - 1;
684	EndLoc = *PL;
685	}
686
687	commit.insertAfterToken(loc: EndLoc, text: ClassString);
688	return true;
689	}
690
691	static StringRef GetUnsignedName(StringRef NSIntegerName) {
692	StringRef UnsignedName = llvm::StringSwitch<StringRef>(NSIntegerName)
693	.Case(S: "int8_t", Value: "uint8_t")
694	.Case(S: "int16_t", Value: "uint16_t")
695	.Case(S: "int32_t", Value: "uint32_t")
696	.Case(S: "NSInteger", Value: "NSUInteger")
697	.Case(S: "int64_t", Value: "uint64_t")
698	.Default(Value: NSIntegerName);
699	return UnsignedName;
700	}
701
702	static bool rewriteToNSEnumDecl(const EnumDecl *EnumDcl,
703	const TypedefDecl *TypedefDcl,
704	const NSAPI &NS, edit::Commit &commit,
705	StringRef NSIntegerName,
706	bool NSOptions) {
707	std::string ClassString;
708	if (NSOptions) {
709	ClassString = "typedef NS_OPTIONS(";
710	ClassString += GetUnsignedName(NSIntegerName);
711	}
712	else {
713	ClassString = "typedef NS_ENUM(";
714	ClassString += NSIntegerName;
715	}
716	ClassString += ", ";
717
718	ClassString += TypedefDcl->getIdentifier()->getName();
719	ClassString += ')';
720	SourceRange R(EnumDcl->getBeginLoc(), EnumDcl->getBeginLoc());
721	commit.replace(TokenRange: R, text: ClassString);
722	SourceLocation EndOfEnumDclLoc = EnumDcl->getEndLoc();
723	EndOfEnumDclLoc = trans::findSemiAfterLocation(loc: EndOfEnumDclLoc,
724	Ctx&: NS.getASTContext(), /*IsDecl*/true);
725	if (EndOfEnumDclLoc.isValid()) {
726	SourceRange EnumDclRange(EnumDcl->getBeginLoc(), EndOfEnumDclLoc);
727	commit.insertFromRange(TypedefDcl->getBeginLoc(), EnumDclRange);
728	}
729	else
730	return false;
731
732	SourceLocation EndTypedefDclLoc = TypedefDcl->getEndLoc();
733	EndTypedefDclLoc = trans::findSemiAfterLocation(loc: EndTypedefDclLoc,
734	Ctx&: NS.getASTContext(), /*IsDecl*/true);
735	if (EndTypedefDclLoc.isValid()) {
736	SourceRange TDRange(TypedefDcl->getBeginLoc(), EndTypedefDclLoc);
737	commit.remove(TokenRange: TDRange);
738	}
739	else
740	return false;
741
742	EndOfEnumDclLoc =
743	trans::findLocationAfterSemi(loc: EnumDcl->getEndLoc(), Ctx&: NS.getASTContext(),
744	/*IsDecl*/ true);
745	if (EndOfEnumDclLoc.isValid()) {
746	SourceLocation BeginOfEnumDclLoc = EnumDcl->getBeginLoc();
747	// FIXME. This assumes that enum decl; is immediately preceded by eoln.
748	// It is trying to remove the enum decl. lines entirely.
749	BeginOfEnumDclLoc = BeginOfEnumDclLoc.getLocWithOffset(Offset: -1);
750	commit.remove(TokenRange: SourceRange(BeginOfEnumDclLoc, EndOfEnumDclLoc));
751	return true;
752	}
753	return false;
754	}
755
756	static void rewriteToNSMacroDecl(ASTContext &Ctx,
757	const EnumDecl *EnumDcl,
758	const TypedefDecl *TypedefDcl,
759	const NSAPI &NS, edit::Commit &commit,
760	bool IsNSIntegerType) {
761	QualType DesignatedEnumType = EnumDcl->getIntegerType();
762	assert(!DesignatedEnumType.isNull()
763	&& "rewriteToNSMacroDecl - underlying enum type is null");
764
765	PrintingPolicy Policy(Ctx.getPrintingPolicy());
766	std::string TypeString = DesignatedEnumType.getAsString(Policy);
767	std::string ClassString = IsNSIntegerType ? "NS_ENUM(" : "NS_OPTIONS(";
768	ClassString += TypeString;
769	ClassString += ", ";
770
771	ClassString += TypedefDcl->getIdentifier()->getName();
772	ClassString += ") ";
773	SourceLocation EndLoc = EnumDcl->getBraceRange().getBegin();
774	if (EndLoc.isInvalid())
775	return;
776	CharSourceRange R =
777	CharSourceRange::getCharRange(EnumDcl->getBeginLoc(), EndLoc);
778	commit.replace(range: R, text: ClassString);
779	// This is to remove spaces between '}' and typedef name.
780	SourceLocation StartTypedefLoc = EnumDcl->getEndLoc();
781	StartTypedefLoc = StartTypedefLoc.getLocWithOffset(Offset: +1);
782	SourceLocation EndTypedefLoc = TypedefDcl->getEndLoc();
783
784	commit.remove(TokenRange: SourceRange(StartTypedefLoc, EndTypedefLoc));
785	}
786
787	static bool UseNSOptionsMacro(Preprocessor &PP, ASTContext &Ctx,
788	const EnumDecl *EnumDcl) {
789	bool PowerOfTwo = true;
790	bool AllHexdecimalEnumerator = true;
791	uint64_t MaxPowerOfTwoVal = 0;
792	for (auto *Enumerator : EnumDcl->enumerators()) {
793	const Expr *InitExpr = Enumerator->getInitExpr();
794	if (!InitExpr) {
795	PowerOfTwo = false;
796	AllHexdecimalEnumerator = false;
797	continue;
798	}
799	InitExpr = InitExpr->IgnoreParenCasts();
800	if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(Val: InitExpr))
801	if (BO->isShiftOp() || BO->isBitwiseOp())
802	return true;
803
804	uint64_t EnumVal = Enumerator->getInitVal().getZExtValue();
805	if (PowerOfTwo && EnumVal) {
806	if (!llvm::isPowerOf2_64(Value: EnumVal))
807	PowerOfTwo = false;
808	else if (EnumVal > MaxPowerOfTwoVal)
809	MaxPowerOfTwoVal = EnumVal;
810	}
811	if (AllHexdecimalEnumerator && EnumVal) {
812	bool FoundHexdecimalEnumerator = false;
813	SourceLocation EndLoc = Enumerator->getEndLoc();
814	Token Tok;
815	if (!PP.getRawToken(Loc: EndLoc, Result&: Tok, /*IgnoreWhiteSpace=*/true))
816	if (Tok.isLiteral() && Tok.getLength() > 2) {
817	if (const char *StringLit = Tok.getLiteralData())
818	FoundHexdecimalEnumerator =
819	(StringLit[0] == '0' && (toLowercase(c: StringLit[1]) == 'x'));
820	}
821	if (!FoundHexdecimalEnumerator)
822	AllHexdecimalEnumerator = false;
823	}
824	}
825	return AllHexdecimalEnumerator || (PowerOfTwo && (MaxPowerOfTwoVal > 2));
826	}
827
828	void ObjCMigrateASTConsumer::migrateProtocolConformance(ASTContext &Ctx,
829	const ObjCImplementationDecl *ImpDecl) {
830	const ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface();
831	if (!IDecl || ObjCProtocolDecls.empty() || IDecl->isDeprecated())
832	return;
833	// Find all implicit conforming protocols for this class
834	// and make them explicit.
835	llvm::SmallPtrSet<ObjCProtocolDecl *, 8> ExplicitProtocols;
836	Ctx.CollectInheritedProtocols(IDecl, ExplicitProtocols);
837	llvm::SmallVector<ObjCProtocolDecl *, 8> PotentialImplicitProtocols;
838
839	for (ObjCProtocolDecl *ProtDecl : ObjCProtocolDecls)
840	if (!ExplicitProtocols.count(Ptr: ProtDecl))
841	PotentialImplicitProtocols.push_back(Elt: ProtDecl);
842
843	if (PotentialImplicitProtocols.empty())
844	return;
845
846	// go through list of non-optional methods and properties in each protocol
847	// in the PotentialImplicitProtocols list. If class implements every one of the
848	// methods and properties, then this class conforms to this protocol.
849	llvm::SmallVector<ObjCProtocolDecl*, 8> ConformingProtocols;
850	for (unsigned i = 0, e = PotentialImplicitProtocols.size(); i != e; i++)
851	if (ClassImplementsAllMethodsAndProperties(Ctx, ImpDecl, IDecl,
852	Protocol: PotentialImplicitProtocols[i]))
853	ConformingProtocols.push_back(Elt: PotentialImplicitProtocols[i]);
854
855	if (ConformingProtocols.empty())
856	return;
857
858	// Further reduce number of conforming protocols. If protocol P1 is in the list
859	// protocol P2 (P2<P1>), No need to include P1.
860	llvm::SmallVector<ObjCProtocolDecl*, 8> MinimalConformingProtocols;
861	for (unsigned i = 0, e = ConformingProtocols.size(); i != e; i++) {
862	bool DropIt = false;
863	ObjCProtocolDecl *TargetPDecl = ConformingProtocols[i];
864	for (unsigned i1 = 0, e1 = ConformingProtocols.size(); i1 != e1; i1++) {
865	ObjCProtocolDecl *PDecl = ConformingProtocols[i1];
866	if (PDecl == TargetPDecl)
867	continue;
868	if (PDecl->lookupProtocolNamed(
869	PName: TargetPDecl->getDeclName().getAsIdentifierInfo())) {
870	DropIt = true;
871	break;
872	}
873	}
874	if (!DropIt)
875	MinimalConformingProtocols.push_back(Elt: TargetPDecl);
876	}
877	if (MinimalConformingProtocols.empty())
878	return;
879	edit::Commit commit(*Editor);
880	rewriteToObjCInterfaceDecl(IDecl, ConformingProtocols&: MinimalConformingProtocols,
881	NS: *NSAPIObj, commit);
882	Editor->commit(commit);
883	}
884
885	void ObjCMigrateASTConsumer::CacheObjCNSIntegerTypedefed(
886	const TypedefDecl *TypedefDcl) {
887
888	QualType qt = TypedefDcl->getTypeSourceInfo()->getType();
889	if (NSAPIObj->isObjCNSIntegerType(T: qt))
890	NSIntegerTypedefed = TypedefDcl;
891	else if (NSAPIObj->isObjCNSUIntegerType(T: qt))
892	NSUIntegerTypedefed = TypedefDcl;
893	}
894
895	bool ObjCMigrateASTConsumer::migrateNSEnumDecl(ASTContext &Ctx,
896	const EnumDecl *EnumDcl,
897	const TypedefDecl *TypedefDcl) {
898	if (!EnumDcl->isCompleteDefinition() || EnumDcl->getIdentifier() ||
899	EnumDcl->isDeprecated())
900	return false;
901	if (!TypedefDcl) {
902	if (NSIntegerTypedefed) {
903	TypedefDcl = NSIntegerTypedefed;
904	NSIntegerTypedefed = nullptr;
905	}
906	else if (NSUIntegerTypedefed) {
907	TypedefDcl = NSUIntegerTypedefed;
908	NSUIntegerTypedefed = nullptr;
909	}
910	else
911	return false;
912	FileID FileIdOfTypedefDcl =
913	PP.getSourceManager().getFileID(TypedefDcl->getLocation());
914	FileID FileIdOfEnumDcl =
915	PP.getSourceManager().getFileID(EnumDcl->getLocation());
916	if (FileIdOfTypedefDcl != FileIdOfEnumDcl)
917	return false;
918	}
919	if (TypedefDcl->isDeprecated())
920	return false;
921
922	QualType qt = TypedefDcl->getTypeSourceInfo()->getType();
923	StringRef NSIntegerName = NSAPIObj->GetNSIntegralKind(T: qt);
924
925	if (NSIntegerName.empty()) {
926	// Also check for typedef enum {...} TD;
927	if (const EnumType *EnumTy = qt->getAs<EnumType>()) {
928	if (EnumTy->getDecl() == EnumDcl) {
929	bool NSOptions = UseNSOptionsMacro(PP, Ctx, EnumDcl);
930	if (!InsertFoundation(Ctx, Loc: TypedefDcl->getBeginLoc()))
931	return false;
932	edit::Commit commit(*Editor);
933	rewriteToNSMacroDecl(Ctx, EnumDcl, TypedefDcl, NS: *NSAPIObj, commit, IsNSIntegerType: !NSOptions);
934	Editor->commit(commit);
935	return true;
936	}
937	}
938	return false;
939	}
940
941	// We may still use NS_OPTIONS based on what we find in the enumertor list.
942	bool NSOptions = UseNSOptionsMacro(PP, Ctx, EnumDcl);
943	if (!InsertFoundation(Ctx, Loc: TypedefDcl->getBeginLoc()))
944	return false;
945	edit::Commit commit(*Editor);
946	bool Res = rewriteToNSEnumDecl(EnumDcl, TypedefDcl, NS: *NSAPIObj,
947	commit, NSIntegerName, NSOptions);
948	Editor->commit(commit);
949	return Res;
950	}
951
952	static void ReplaceWithInstancetype(ASTContext &Ctx,
953	const ObjCMigrateASTConsumer &ASTC,
954	ObjCMethodDecl *OM) {
955	if (OM->getReturnType() == Ctx.getObjCInstanceType())
956	return; // already has instancetype.
957
958	SourceRange R;
959	std::string ClassString;
960	if (TypeSourceInfo *TSInfo = OM->getReturnTypeSourceInfo()) {
961	TypeLoc TL = TSInfo->getTypeLoc();
962	R = SourceRange(TL.getBeginLoc(), TL.getEndLoc());
963	ClassString = "instancetype";
964	}
965	else {
966	R = SourceRange(OM->getBeginLoc(), OM->getBeginLoc());
967	ClassString = OM->isInstanceMethod() ? '-' : '+';
968	ClassString += " (instancetype)";
969	}
970	edit::Commit commit(*ASTC.Editor);
971	commit.replace(TokenRange: R, text: ClassString);
972	ASTC.Editor->commit(commit);
973	}
974
975	static void ReplaceWithClasstype(const ObjCMigrateASTConsumer &ASTC,
976	ObjCMethodDecl *OM) {
977	ObjCInterfaceDecl *IDecl = OM->getClassInterface();
978	SourceRange R;
979	std::string ClassString;
980	if (TypeSourceInfo *TSInfo = OM->getReturnTypeSourceInfo()) {
981	TypeLoc TL = TSInfo->getTypeLoc();
982	R = SourceRange(TL.getBeginLoc(), TL.getEndLoc()); {
983	ClassString = std::string(IDecl->getName());
984	ClassString += "*";
985	}
986	}
987	else {
988	R = SourceRange(OM->getBeginLoc(), OM->getBeginLoc());
989	ClassString = "+ (";
990	ClassString += IDecl->getName(); ClassString += "*)";
991	}
992	edit::Commit commit(*ASTC.Editor);
993	commit.replace(TokenRange: R, text: ClassString);
994	ASTC.Editor->commit(commit);
995	}
996
997	void ObjCMigrateASTConsumer::migrateMethodInstanceType(ASTContext &Ctx,
998	ObjCContainerDecl *CDecl,
999	ObjCMethodDecl *OM) {
1000	ObjCInstanceTypeFamily OIT_Family =
1001	Selector::getInstTypeMethodFamily(sel: OM->getSelector());
1002
1003	std::string ClassName;
1004	switch (OIT_Family) {
1005	case OIT_None:
1006	migrateFactoryMethod(Ctx, CDecl, OM);
1007	return;
1008	case OIT_Array:
1009	ClassName = "NSArray";
1010	break;
1011	case OIT_Dictionary:
1012	ClassName = "NSDictionary";
1013	break;
1014	case OIT_Singleton:
1015	migrateFactoryMethod(Ctx, CDecl, OM, OIT_Family: OIT_Singleton);
1016	return;
1017	case OIT_Init:
1018	if (OM->getReturnType()->isObjCIdType())
1019	ReplaceWithInstancetype(Ctx, ASTC: *this, OM);
1020	return;
1021	case OIT_ReturnsSelf:
1022	migrateFactoryMethod(Ctx, CDecl, OM, OIT_Family: OIT_ReturnsSelf);
1023	return;
1024	}
1025	if (!OM->getReturnType()->isObjCIdType())
1026	return;
1027
1028	ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(Val: CDecl);
1029	if (!IDecl) {
1030	if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(Val: CDecl))
1031	IDecl = CatDecl->getClassInterface();
1032	else if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(Val: CDecl))
1033	IDecl = ImpDecl->getClassInterface();
1034	}
1035	if (!IDecl ||
1036	!IDecl->lookupInheritedClass(ICName: &Ctx.Idents.get(Name: ClassName))) {
1037	migrateFactoryMethod(Ctx, CDecl, OM);
1038	return;
1039	}
1040	ReplaceWithInstancetype(Ctx, ASTC: *this, OM);
1041	}
1042
1043	static bool TypeIsInnerPointer(QualType T) {
1044	if (!T->isAnyPointerType())
1045	return false;
1046	if (T->isObjCObjectPointerType() || T->isObjCBuiltinType() ||
1047	T->isBlockPointerType() || T->isFunctionPointerType() ||
1048	ento::coreFoundation::isCFObjectRef(T))
1049	return false;
1050	// Also, typedef-of-pointer-to-incomplete-struct is something that we assume
1051	// is not an innter pointer type.
1052	QualType OrigT = T;
1053	while (const auto *TD = T->getAs<TypedefType>())
1054	T = TD->getDecl()->getUnderlyingType();
1055	if (OrigT == T || !T->isPointerType())
1056	return true;
1057	const PointerType* PT = T->getAs<PointerType>();
1058	QualType UPointeeT = PT->getPointeeType().getUnqualifiedType();
1059	if (UPointeeT->isRecordType()) {
1060	const RecordType *RecordTy = UPointeeT->getAs<RecordType>();
1061	if (!RecordTy->getDecl()->isCompleteDefinition())
1062	return false;
1063	}
1064	return true;
1065	}
1066
1067	/// Check whether the two versions match.
1068	static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y) {
1069	return (X == Y);
1070	}
1071
1072	/// AvailabilityAttrsMatch - This routine checks that if comparing two
1073	/// availability attributes, all their components match. It returns
1074	/// true, if not dealing with availability or when all components of
1075	/// availability attributes match. This routine is only called when
1076	/// the attributes are of the same kind.
1077	static bool AvailabilityAttrsMatch(Attr *At1, Attr *At2) {
1078	const AvailabilityAttr *AA1 = dyn_cast<AvailabilityAttr>(At1);
1079	if (!AA1)
1080	return true;
1081	const AvailabilityAttr *AA2 = cast<AvailabilityAttr>(At2);
1082
1083	VersionTuple Introduced1 = AA1->getIntroduced();
1084	VersionTuple Deprecated1 = AA1->getDeprecated();
1085	VersionTuple Obsoleted1 = AA1->getObsoleted();
1086	bool IsUnavailable1 = AA1->getUnavailable();
1087	VersionTuple Introduced2 = AA2->getIntroduced();
1088	VersionTuple Deprecated2 = AA2->getDeprecated();
1089	VersionTuple Obsoleted2 = AA2->getObsoleted();
1090	bool IsUnavailable2 = AA2->getUnavailable();
1091	return (versionsMatch(X: Introduced1, Y: Introduced2) &&
1092	versionsMatch(X: Deprecated1, Y: Deprecated2) &&
1093	versionsMatch(X: Obsoleted1, Y: Obsoleted2) &&
1094	IsUnavailable1 == IsUnavailable2);
1095	}
1096
1097	static bool MatchTwoAttributeLists(const AttrVec &Attrs1, const AttrVec &Attrs2,
1098	bool &AvailabilityArgsMatch) {
1099	// This list is very small, so this need not be optimized.
1100	for (unsigned i = 0, e = Attrs1.size(); i != e; i++) {
1101	bool match = false;
1102	for (unsigned j = 0, f = Attrs2.size(); j != f; j++) {
1103	// Matching attribute kind only. Except for Availability attributes,
1104	// we are not getting into details of the attributes. For all practical purposes
1105	// this is sufficient.
1106	if (Attrs1[i]->getKind() == Attrs2[j]->getKind()) {
1107	if (AvailabilityArgsMatch)
1108	AvailabilityArgsMatch = AvailabilityAttrsMatch(At1: Attrs1[i], At2: Attrs2[j]);
1109	match = true;
1110	break;
1111	}
1112	}
1113	if (!match)
1114	return false;
1115	}
1116	return true;
1117	}
1118
1119	/// AttributesMatch - This routine checks list of attributes for two
1120	/// decls. It returns false, if there is a mismatch in kind of
1121	/// attributes seen in the decls. It returns true if the two decls
1122	/// have list of same kind of attributes. Furthermore, when there
1123	/// are availability attributes in the two decls, it sets the
1124	/// AvailabilityArgsMatch to false if availability attributes have
1125	/// different versions, etc.
1126	static bool AttributesMatch(const Decl *Decl1, const Decl *Decl2,
1127	bool &AvailabilityArgsMatch) {
1128	if (!Decl1->hasAttrs() || !Decl2->hasAttrs()) {
1129	AvailabilityArgsMatch = (Decl1->hasAttrs() == Decl2->hasAttrs());
1130	return true;
1131	}
1132	AvailabilityArgsMatch = true;
1133	const AttrVec &Attrs1 = Decl1->getAttrs();
1134	const AttrVec &Attrs2 = Decl2->getAttrs();
1135	bool match = MatchTwoAttributeLists(Attrs1, Attrs2, AvailabilityArgsMatch);
1136	if (match && (Attrs2.size() > Attrs1.size()))
1137	return MatchTwoAttributeLists(Attrs1: Attrs2, Attrs2: Attrs1, AvailabilityArgsMatch);
1138	return match;
1139	}
1140
1141	static bool IsValidIdentifier(ASTContext &Ctx,
1142	const char *Name) {
1143	if (!isAsciiIdentifierStart(c: Name[0]))
1144	return false;
1145	std::string NameString = Name;
1146	NameString[0] = toLowercase(c: NameString[0]);
1147	IdentifierInfo *II = &Ctx.Idents.get(Name: NameString);
1148	return II->getTokenID() == tok::identifier;
1149	}
1150
1151	bool ObjCMigrateASTConsumer::migrateProperty(ASTContext &Ctx,
1152	ObjCContainerDecl *D,
1153	ObjCMethodDecl *Method) {
1154	if (Method->isPropertyAccessor() || !Method->isInstanceMethod() ||
1155	Method->param_size() != 0)
1156	return false;
1157	// Is this method candidate to be a getter?
1158	QualType GRT = Method->getReturnType();
1159	if (GRT->isVoidType())
1160	return false;
1161
1162	Selector GetterSelector = Method->getSelector();
1163	ObjCInstanceTypeFamily OIT_Family =
1164	Selector::getInstTypeMethodFamily(sel: GetterSelector);
1165
1166	if (OIT_Family != OIT_None)
1167	return false;
1168
1169	IdentifierInfo *getterName = GetterSelector.getIdentifierInfoForSlot(argIndex: 0);
1170	Selector SetterSelector =
1171	SelectorTable::constructSetterSelector(Idents&: PP.getIdentifierTable(),
1172	SelTable&: PP.getSelectorTable(),
1173	Name: getterName);
1174	ObjCMethodDecl *SetterMethod = D->getInstanceMethod(Sel: SetterSelector);
1175	unsigned LengthOfPrefix = 0;
1176	if (!SetterMethod) {
1177	// try a different naming convention for getter: isXxxxx
1178	StringRef getterNameString = getterName->getName();
1179	bool IsPrefix = getterNameString.starts_with(Prefix: "is");
1180	// Note that we don't want to change an isXXX method of retainable object
1181	// type to property (readonly or otherwise).
1182	if (IsPrefix && GRT->isObjCRetainableType())
1183	return false;
1184	if (IsPrefix || getterNameString.starts_with(Prefix: "get")) {
1185	LengthOfPrefix = (IsPrefix ? 2 : 3);
1186	const char *CGetterName = getterNameString.data() + LengthOfPrefix;
1187	// Make sure that first character after "is" or "get" prefix can
1188	// start an identifier.
1189	if (!IsValidIdentifier(Ctx, Name: CGetterName))
1190	return false;
1191	if (CGetterName[0] && isUppercase(c: CGetterName[0])) {
1192	getterName = &Ctx.Idents.get(Name: CGetterName);
1193	SetterSelector =
1194	SelectorTable::constructSetterSelector(Idents&: PP.getIdentifierTable(),
1195	SelTable&: PP.getSelectorTable(),
1196	Name: getterName);
1197	SetterMethod = D->getInstanceMethod(Sel: SetterSelector);
1198	}
1199	}
1200	}
1201
1202	if (SetterMethod) {
1203	if ((ASTMigrateActions & FrontendOptions::ObjCMT_ReadwriteProperty) == 0)
1204	return false;
1205	bool AvailabilityArgsMatch;
1206	if (SetterMethod->isDeprecated() ||
1207	!AttributesMatch(Method, SetterMethod, AvailabilityArgsMatch))
1208	return false;
1209
1210	// Is this a valid setter, matching the target getter?
1211	QualType SRT = SetterMethod->getReturnType();
1212	if (!SRT->isVoidType())
1213	return false;
1214	const ParmVarDecl *argDecl = *SetterMethod->param_begin();
1215	QualType ArgType = argDecl->getType();
1216	if (!Ctx.hasSameUnqualifiedType(T1: ArgType, T2: GRT))
1217	return false;
1218	edit::Commit commit(*Editor);
1219	rewriteToObjCProperty(Getter: Method, Setter: SetterMethod, NS: *NSAPIObj, commit,
1220	LengthOfPrefix,
1221	Atomic: (ASTMigrateActions &
1222	FrontendOptions::ObjCMT_AtomicProperty) != 0,
1223	UseNsIosOnlyMacro: (ASTMigrateActions &
1224	FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty) != 0,
1225	AvailabilityArgsMatch);
1226	Editor->commit(commit);
1227	return true;
1228	}
1229	else if (ASTMigrateActions & FrontendOptions::ObjCMT_ReadonlyProperty) {
1230	// Try a non-void method with no argument (and no setter or property of same name
1231	// as a 'readonly' property.
1232	edit::Commit commit(*Editor);
1233	rewriteToObjCProperty(Getter: Method, Setter: nullptr /*SetterMethod*/, NS: *NSAPIObj, commit,
1234	LengthOfPrefix,
1235	Atomic: (ASTMigrateActions &
1236	FrontendOptions::ObjCMT_AtomicProperty) != 0,
1237	UseNsIosOnlyMacro: (ASTMigrateActions &
1238	FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty) != 0,
1239	/*AvailabilityArgsMatch*/false);
1240	Editor->commit(commit);
1241	return true;
1242	}
1243	return false;
1244	}
1245
1246	void ObjCMigrateASTConsumer::migrateNsReturnsInnerPointer(ASTContext &Ctx,
1247	ObjCMethodDecl *OM) {
1248	if (OM->isImplicit() ||
1249	!OM->isInstanceMethod() ||
1250	OM->hasAttr<ObjCReturnsInnerPointerAttr>())
1251	return;
1252
1253	QualType RT = OM->getReturnType();
1254	if (!TypeIsInnerPointer(T: RT) ||
1255	!NSAPIObj->isMacroDefined(Id: "NS_RETURNS_INNER_POINTER"))
1256	return;
1257
1258	edit::Commit commit(*Editor);
1259	commit.insertBefore(loc: OM->getEndLoc(), text: " NS_RETURNS_INNER_POINTER");
1260	Editor->commit(commit);
1261	}
1262
1263	void ObjCMigrateASTConsumer::migratePropertyNsReturnsInnerPointer(ASTContext &Ctx,
1264	ObjCPropertyDecl *P) {
1265	QualType T = P->getType();
1266
1267	if (!TypeIsInnerPointer(T) ||
1268	!NSAPIObj->isMacroDefined(Id: "NS_RETURNS_INNER_POINTER"))
1269	return;
1270	edit::Commit commit(*Editor);
1271	commit.insertBefore(loc: P->getEndLoc(), text: " NS_RETURNS_INNER_POINTER ");
1272	Editor->commit(commit);
1273	}
1274
1275	void ObjCMigrateASTConsumer::migrateAllMethodInstaceType(ASTContext &Ctx,
1276	ObjCContainerDecl *CDecl) {
1277	if (CDecl->isDeprecated() || IsCategoryNameWithDeprecatedSuffix(D: CDecl))
1278	return;
1279
1280	// migrate methods which can have instancetype as their result type.
1281	for (auto *Method : CDecl->methods()) {
1282	if (Method->isDeprecated())
1283	continue;
1284	migrateMethodInstanceType(Ctx, CDecl, OM: Method);
1285	}
1286	}
1287
1288	void ObjCMigrateASTConsumer::migrateFactoryMethod(ASTContext &Ctx,
1289	ObjCContainerDecl *CDecl,
1290	ObjCMethodDecl *OM,
1291	ObjCInstanceTypeFamily OIT_Family) {
1292	if (OM->isInstanceMethod() ||
1293	OM->getReturnType() == Ctx.getObjCInstanceType() ||
1294	!OM->getReturnType()->isObjCIdType())
1295	return;
1296
1297	// Candidate factory methods are + (id) NaMeXXX : ... which belong to a class
1298	// NSYYYNamE with matching names be at least 3 characters long.
1299	ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(Val: CDecl);
1300	if (!IDecl) {
1301	if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(Val: CDecl))
1302	IDecl = CatDecl->getClassInterface();
1303	else if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(Val: CDecl))
1304	IDecl = ImpDecl->getClassInterface();
1305	}
1306	if (!IDecl)
1307	return;
1308
1309	std::string StringClassName = std::string(IDecl->getName());
1310	StringRef LoweredClassName(StringClassName);
1311	std::string StringLoweredClassName = LoweredClassName.lower();
1312	LoweredClassName = StringLoweredClassName;
1313
1314	IdentifierInfo *MethodIdName = OM->getSelector().getIdentifierInfoForSlot(argIndex: 0);
1315	// Handle method with no name at its first selector slot; e.g. + (id):(int)x.
1316	if (!MethodIdName)
1317	return;
1318
1319	std::string MethodName = std::string(MethodIdName->getName());
1320	if (OIT_Family == OIT_Singleton || OIT_Family == OIT_ReturnsSelf) {
1321	StringRef STRefMethodName(MethodName);
1322	size_t len = 0;
1323	if (STRefMethodName.starts_with(Prefix: "standard"))
1324	len = strlen(s: "standard");
1325	else if (STRefMethodName.starts_with(Prefix: "shared"))
1326	len = strlen(s: "shared");
1327	else if (STRefMethodName.starts_with(Prefix: "default"))
1328	len = strlen(s: "default");
1329	else
1330	return;
1331	MethodName = std::string(STRefMethodName.substr(Start: len));
1332	}
1333	std::string MethodNameSubStr = MethodName.substr(pos: 0, n: 3);
1334	StringRef MethodNamePrefix(MethodNameSubStr);
1335	std::string StringLoweredMethodNamePrefix = MethodNamePrefix.lower();
1336	MethodNamePrefix = StringLoweredMethodNamePrefix;
1337	size_t Ix = LoweredClassName.rfind(Str: MethodNamePrefix);
1338	if (Ix == StringRef::npos)
1339	return;
1340	std::string ClassNamePostfix = std::string(LoweredClassName.substr(Start: Ix));
1341	StringRef LoweredMethodName(MethodName);
1342	std::string StringLoweredMethodName = LoweredMethodName.lower();
1343	LoweredMethodName = StringLoweredMethodName;
1344	if (!LoweredMethodName.starts_with(Prefix: ClassNamePostfix))
1345	return;
1346	if (OIT_Family == OIT_ReturnsSelf)
1347	ReplaceWithClasstype(ASTC: *this, OM);
1348	else
1349	ReplaceWithInstancetype(Ctx, ASTC: *this, OM);
1350	}
1351
1352	static bool IsVoidStarType(QualType Ty) {
1353	if (!Ty->isPointerType())
1354	return false;
1355
1356	// Is the type void*?
1357	const PointerType* PT = Ty->castAs<PointerType>();
1358	if (PT->getPointeeType().getUnqualifiedType()->isVoidType())
1359	return true;
1360	return IsVoidStarType(Ty: PT->getPointeeType());
1361	}
1362
1363	/// AuditedType - This routine audits the type AT and returns false if it is one of known
1364	/// CF object types or of the "void *" variety. It returns true if we don't care about the type
1365	/// such as a non-pointer or pointers which have no ownership issues (such as "int *").
1366	static bool AuditedType (QualType AT) {
1367	if (!AT->isAnyPointerType() && !AT->isBlockPointerType())
1368	return true;
1369	// FIXME. There isn't much we can say about CF pointer type; or is there?
1370	if (ento::coreFoundation::isCFObjectRef(T: AT) ||
1371	IsVoidStarType(Ty: AT) ||
1372	// If an ObjC object is type, assuming that it is not a CF function and
1373	// that it is an un-audited function.
1374	AT->isObjCObjectPointerType() || AT->isObjCBuiltinType())
1375	return false;
1376	// All other pointers are assumed audited as harmless.
1377	return true;
1378	}
1379
1380	void ObjCMigrateASTConsumer::AnnotateImplicitBridging(ASTContext &Ctx) {
1381	if (CFFunctionIBCandidates.empty())
1382	return;
1383	if (!NSAPIObj->isMacroDefined(Id: "CF_IMPLICIT_BRIDGING_ENABLED")) {
1384	CFFunctionIBCandidates.clear();
1385	FileId = FileID();
1386	return;
1387	}
1388	// Insert CF_IMPLICIT_BRIDGING_ENABLE/CF_IMPLICIT_BRIDGING_DISABLED
1389	const Decl *FirstFD = CFFunctionIBCandidates[0];
1390	const Decl *LastFD =
1391	CFFunctionIBCandidates[CFFunctionIBCandidates.size()-1];
1392	const char *PragmaString = "\nCF_IMPLICIT_BRIDGING_ENABLED\n\n";
1393	edit::Commit commit(*Editor);
1394	commit.insertBefore(loc: FirstFD->getBeginLoc(), text: PragmaString);
1395	PragmaString = "\n\nCF_IMPLICIT_BRIDGING_DISABLED\n";
1396	SourceLocation EndLoc = LastFD->getEndLoc();
1397	// get location just past end of function location.
1398	EndLoc = PP.getLocForEndOfToken(Loc: EndLoc);
1399	if (isa<FunctionDecl>(Val: LastFD)) {
1400	// For Methods, EndLoc points to the ending semcolon. So,
1401	// not of these extra work is needed.
1402	Token Tok;
1403	// get locaiton of token that comes after end of function.
1404	bool Failed = PP.getRawToken(Loc: EndLoc, Result&: Tok, /*IgnoreWhiteSpace=*/true);
1405	if (!Failed)
1406	EndLoc = Tok.getLocation();
1407	}
1408	commit.insertAfterToken(loc: EndLoc, text: PragmaString);
1409	Editor->commit(commit);
1410	FileId = FileID();
1411	CFFunctionIBCandidates.clear();
1412	}
1413
1414	void ObjCMigrateASTConsumer::migrateCFAnnotation(ASTContext &Ctx, const Decl *Decl) {
1415	if (Decl->isDeprecated())
1416	return;
1417
1418	if (Decl->hasAttr<CFAuditedTransferAttr>()) {
1419	assert(CFFunctionIBCandidates.empty() &&
1420	"Cannot have audited functions/methods inside user "
1421	"provided CF_IMPLICIT_BRIDGING_ENABLE");
1422	return;
1423	}
1424
1425	// Finction must be annotated first.
1426	if (const FunctionDecl *FuncDecl = dyn_cast<FunctionDecl>(Val: Decl)) {
1427	CF_BRIDGING_KIND AuditKind = migrateAddFunctionAnnotation(Ctx, FuncDecl);
1428	if (AuditKind == CF_BRIDGING_ENABLE) {
1429	CFFunctionIBCandidates.push_back(Elt: Decl);
1430	if (FileId.isInvalid())
1431	FileId = PP.getSourceManager().getFileID(SpellingLoc: Decl->getLocation());
1432	}
1433	else if (AuditKind == CF_BRIDGING_MAY_INCLUDE) {
1434	if (!CFFunctionIBCandidates.empty()) {
1435	CFFunctionIBCandidates.push_back(Elt: Decl);
1436	if (FileId.isInvalid())
1437	FileId = PP.getSourceManager().getFileID(SpellingLoc: Decl->getLocation());
1438	}
1439	}
1440	else
1441	AnnotateImplicitBridging(Ctx);
1442	}
1443	else {
1444	migrateAddMethodAnnotation(Ctx, MethodDecl: cast<ObjCMethodDecl>(Val: Decl));
1445	AnnotateImplicitBridging(Ctx);
1446	}
1447	}
1448
1449	void ObjCMigrateASTConsumer::AddCFAnnotations(ASTContext &Ctx,
1450	const RetainSummary *RS,
1451	const FunctionDecl *FuncDecl,
1452	bool ResultAnnotated) {
1453	// Annotate function.
1454	if (!ResultAnnotated) {
1455	RetEffect Ret = RS->getRetEffect();
1456	const char *AnnotationString = nullptr;
1457	if (Ret.getObjKind() == ObjKind::CF) {
1458	if (Ret.isOwned() && NSAPIObj->isMacroDefined(Id: "CF_RETURNS_RETAINED"))
1459	AnnotationString = " CF_RETURNS_RETAINED";
1460	else if (Ret.notOwned() &&
1461	NSAPIObj->isMacroDefined(Id: "CF_RETURNS_NOT_RETAINED"))
1462	AnnotationString = " CF_RETURNS_NOT_RETAINED";
1463	}
1464	else if (Ret.getObjKind() == ObjKind::ObjC) {
1465	if (Ret.isOwned() && NSAPIObj->isMacroDefined(Id: "NS_RETURNS_RETAINED"))
1466	AnnotationString = " NS_RETURNS_RETAINED";
1467	}
1468
1469	if (AnnotationString) {
1470	edit::Commit commit(*Editor);
1471	commit.insertAfterToken(loc: FuncDecl->getEndLoc(), text: AnnotationString);
1472	Editor->commit(commit);
1473	}
1474	}
1475	unsigned i = 0;
1476	for (FunctionDecl::param_const_iterator pi = FuncDecl->param_begin(),
1477	pe = FuncDecl->param_end(); pi != pe; ++pi, ++i) {
1478	const ParmVarDecl *pd = *pi;
1479	ArgEffect AE = RS->getArg(idx: i);
1480	if (AE.getKind() == DecRef && AE.getObjKind() == ObjKind::CF &&
1481	!pd->hasAttr<CFConsumedAttr>() &&
1482	NSAPIObj->isMacroDefined("CF_CONSUMED")) {
1483	edit::Commit commit(*Editor);
1484	commit.insertBefore(loc: pd->getLocation(), text: "CF_CONSUMED ");
1485	Editor->commit(commit);
1486	} else if (AE.getKind() == DecRef && AE.getObjKind() == ObjKind::ObjC &&
1487	!pd->hasAttr<NSConsumedAttr>() &&
1488	NSAPIObj->isMacroDefined("NS_CONSUMED")) {
1489	edit::Commit commit(*Editor);
1490	commit.insertBefore(loc: pd->getLocation(), text: "NS_CONSUMED ");
1491	Editor->commit(commit);
1492	}
1493	}
1494	}
1495
1496	ObjCMigrateASTConsumer::CF_BRIDGING_KIND
1497	ObjCMigrateASTConsumer::migrateAddFunctionAnnotation(
1498	ASTContext &Ctx,
1499	const FunctionDecl *FuncDecl) {
1500	if (FuncDecl->hasBody())
1501	return CF_BRIDGING_NONE;
1502
1503	const RetainSummary *RS =
1504	getSummaryManager(Ctx).getSummary(C: AnyCall(FuncDecl));
1505	bool FuncIsReturnAnnotated = (FuncDecl->hasAttr<CFReturnsRetainedAttr>() ||
1506	FuncDecl->hasAttr<CFReturnsNotRetainedAttr>() ||
1507	FuncDecl->hasAttr<NSReturnsRetainedAttr>() ||
1508	FuncDecl->hasAttr<NSReturnsNotRetainedAttr>() ||
1509	FuncDecl->hasAttr<NSReturnsAutoreleasedAttr>());
1510
1511	// Trivial case of when function is annotated and has no argument.
1512	if (FuncIsReturnAnnotated && FuncDecl->getNumParams() == 0)
1513	return CF_BRIDGING_NONE;
1514
1515	bool ReturnCFAudited = false;
1516	if (!FuncIsReturnAnnotated) {
1517	RetEffect Ret = RS->getRetEffect();
1518	if (Ret.getObjKind() == ObjKind::CF &&
1519	(Ret.isOwned() || Ret.notOwned()))
1520	ReturnCFAudited = true;
1521	else if (!AuditedType(AT: FuncDecl->getReturnType()))
1522	return CF_BRIDGING_NONE;
1523	}
1524
1525	// At this point result type is audited for potential inclusion.
1526	unsigned i = 0;
1527	bool ArgCFAudited = false;
1528	for (FunctionDecl::param_const_iterator pi = FuncDecl->param_begin(),
1529	pe = FuncDecl->param_end(); pi != pe; ++pi, ++i) {
1530	const ParmVarDecl *pd = *pi;
1531	ArgEffect AE = RS->getArg(idx: i);
1532	if ((AE.getKind() == DecRef /*CFConsumed annotated*/ ||
1533	AE.getKind() == IncRef) && AE.getObjKind() == ObjKind::CF) {
1534	if (AE.getKind() == DecRef && !pd->hasAttr<CFConsumedAttr>())
1535	ArgCFAudited = true;
1536	else if (AE.getKind() == IncRef)
1537	ArgCFAudited = true;
1538	} else {
1539	QualType AT = pd->getType();
1540	if (!AuditedType(AT)) {
1541	AddCFAnnotations(Ctx, RS, FuncDecl, ResultAnnotated: FuncIsReturnAnnotated);
1542	return CF_BRIDGING_NONE;
1543	}
1544	}
1545	}
1546	if (ReturnCFAudited || ArgCFAudited)
1547	return CF_BRIDGING_ENABLE;
1548
1549	return CF_BRIDGING_MAY_INCLUDE;
1550	}
1551
1552	void ObjCMigrateASTConsumer::migrateARCSafeAnnotation(ASTContext &Ctx,
1553	ObjCContainerDecl *CDecl) {
1554	if (!isa<ObjCInterfaceDecl>(Val: CDecl) || CDecl->isDeprecated())
1555	return;
1556
1557	// migrate methods which can have instancetype as their result type.
1558	for (const auto *Method : CDecl->methods())
1559	migrateCFAnnotation(Ctx, Method);
1560	}
1561
1562	void ObjCMigrateASTConsumer::AddCFAnnotations(ASTContext &Ctx,
1563	const RetainSummary *RS,
1564	const ObjCMethodDecl *MethodDecl,
1565	bool ResultAnnotated) {
1566	// Annotate function.
1567	if (!ResultAnnotated) {
1568	RetEffect Ret = RS->getRetEffect();
1569	const char *AnnotationString = nullptr;
1570	if (Ret.getObjKind() == ObjKind::CF) {
1571	if (Ret.isOwned() && NSAPIObj->isMacroDefined(Id: "CF_RETURNS_RETAINED"))
1572	AnnotationString = " CF_RETURNS_RETAINED";
1573	else if (Ret.notOwned() &&
1574	NSAPIObj->isMacroDefined(Id: "CF_RETURNS_NOT_RETAINED"))
1575	AnnotationString = " CF_RETURNS_NOT_RETAINED";
1576	}
1577	else if (Ret.getObjKind() == ObjKind::ObjC) {
1578	ObjCMethodFamily OMF = MethodDecl->getMethodFamily();
1579	switch (OMF) {
1580	case clang::OMF_alloc:
1581	case clang::OMF_new:
1582	case clang::OMF_copy:
1583	case clang::OMF_init:
1584	case clang::OMF_mutableCopy:
1585	break;
1586
1587	default:
1588	if (Ret.isOwned() && NSAPIObj->isMacroDefined(Id: "NS_RETURNS_RETAINED"))
1589	AnnotationString = " NS_RETURNS_RETAINED";
1590	break;
1591	}
1592	}
1593
1594	if (AnnotationString) {
1595	edit::Commit commit(*Editor);
1596	commit.insertBefore(loc: MethodDecl->getEndLoc(), text: AnnotationString);
1597	Editor->commit(commit);
1598	}
1599	}
1600	unsigned i = 0;
1601	for (ObjCMethodDecl::param_const_iterator pi = MethodDecl->param_begin(),
1602	pe = MethodDecl->param_end(); pi != pe; ++pi, ++i) {
1603	const ParmVarDecl *pd = *pi;
1604	ArgEffect AE = RS->getArg(idx: i);
1605	if (AE.getKind() == DecRef
1606	&& AE.getObjKind() == ObjKind::CF
1607	&& !pd->hasAttr<CFConsumedAttr>() &&
1608	NSAPIObj->isMacroDefined("CF_CONSUMED")) {
1609	edit::Commit commit(*Editor);
1610	commit.insertBefore(loc: pd->getLocation(), text: "CF_CONSUMED ");
1611	Editor->commit(commit);
1612	}
1613	}
1614	}
1615
1616	void ObjCMigrateASTConsumer::migrateAddMethodAnnotation(
1617	ASTContext &Ctx,
1618	const ObjCMethodDecl *MethodDecl) {
1619	if (MethodDecl->hasBody() || MethodDecl->isImplicit())
1620	return;
1621
1622	const RetainSummary *RS =
1623	getSummaryManager(Ctx).getSummary(C: AnyCall(MethodDecl));
1624
1625	bool MethodIsReturnAnnotated =
1626	(MethodDecl->hasAttr<CFReturnsRetainedAttr>() ||
1627	MethodDecl->hasAttr<CFReturnsNotRetainedAttr>() ||
1628	MethodDecl->hasAttr<NSReturnsRetainedAttr>() ||
1629	MethodDecl->hasAttr<NSReturnsNotRetainedAttr>() ||
1630	MethodDecl->hasAttr<NSReturnsAutoreleasedAttr>());
1631
1632	if (RS->getReceiverEffect().getKind() == DecRef &&
1633	!MethodDecl->hasAttr<NSConsumesSelfAttr>() &&
1634	MethodDecl->getMethodFamily() != OMF_init &&
1635	MethodDecl->getMethodFamily() != OMF_release &&
1636	NSAPIObj->isMacroDefined("NS_CONSUMES_SELF")) {
1637	edit::Commit commit(*Editor);
1638	commit.insertBefore(loc: MethodDecl->getEndLoc(), text: " NS_CONSUMES_SELF");
1639	Editor->commit(commit);
1640	}
1641
1642	// Trivial case of when function is annotated and has no argument.
1643	if (MethodIsReturnAnnotated &&
1644	(MethodDecl->param_begin() == MethodDecl->param_end()))
1645	return;
1646
1647	if (!MethodIsReturnAnnotated) {
1648	RetEffect Ret = RS->getRetEffect();
1649	if ((Ret.getObjKind() == ObjKind::CF ||
1650	Ret.getObjKind() == ObjKind::ObjC) &&
1651	(Ret.isOwned() || Ret.notOwned())) {
1652	AddCFAnnotations(Ctx, RS, MethodDecl, ResultAnnotated: false);
1653	return;
1654	} else if (!AuditedType(AT: MethodDecl->getReturnType()))
1655	return;
1656	}
1657
1658	// At this point result type is either annotated or audited.
1659	unsigned i = 0;
1660	for (ObjCMethodDecl::param_const_iterator pi = MethodDecl->param_begin(),
1661	pe = MethodDecl->param_end(); pi != pe; ++pi, ++i) {
1662	const ParmVarDecl *pd = *pi;
1663	ArgEffect AE = RS->getArg(idx: i);
1664	if ((AE.getKind() == DecRef && !pd->hasAttr<CFConsumedAttr>()) ||
1665	AE.getKind() == IncRef || !AuditedType(pd->getType())) {
1666	AddCFAnnotations(Ctx, RS, MethodDecl, ResultAnnotated: MethodIsReturnAnnotated);
1667	return;
1668	}
1669	}
1670	}
1671
1672	namespace {
1673	class SuperInitChecker : public RecursiveASTVisitor<SuperInitChecker> {
1674	public:
1675	bool shouldVisitTemplateInstantiations() const { return false; }
1676	bool shouldWalkTypesOfTypeLocs() const { return false; }
1677
1678	bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
1679	if (E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
1680	if (E->getMethodFamily() == OMF_init)
1681	return false;
1682	}
1683	return true;
1684	}
1685	};
1686	} // end anonymous namespace
1687
1688	static bool hasSuperInitCall(const ObjCMethodDecl *MD) {
1689	return !SuperInitChecker().TraverseStmt(S: MD->getBody());
1690	}
1691
1692	void ObjCMigrateASTConsumer::inferDesignatedInitializers(
1693	ASTContext &Ctx,
1694	const ObjCImplementationDecl *ImplD) {
1695
1696	const ObjCInterfaceDecl *IFace = ImplD->getClassInterface();
1697	if (!IFace || IFace->hasDesignatedInitializers())
1698	return;
1699	if (!NSAPIObj->isMacroDefined(Id: "NS_DESIGNATED_INITIALIZER"))
1700	return;
1701
1702	for (const auto *MD : ImplD->instance_methods()) {
1703	if (MD->isDeprecated() ||
1704	MD->getMethodFamily() != OMF_init ||
1705	MD->isDesignatedInitializerForTheInterface())
1706	continue;
1707	const ObjCMethodDecl *IFaceM = IFace->getMethod(MD->getSelector(),
1708	/*isInstance=*/true);
1709	if (!IFaceM)
1710	continue;
1711	if (hasSuperInitCall(MD)) {
1712	edit::Commit commit(*Editor);
1713	commit.insert(IFaceM->getEndLoc(), " NS_DESIGNATED_INITIALIZER");
1714	Editor->commit(commit);
1715	}
1716	}
1717	}
1718
1719	bool ObjCMigrateASTConsumer::InsertFoundation(ASTContext &Ctx,
1720	SourceLocation Loc) {
1721	if (FoundationIncluded)
1722	return true;
1723	if (Loc.isInvalid())
1724	return false;
1725	auto *nsEnumId = &Ctx.Idents.get(Name: "NS_ENUM");
1726	if (PP.getMacroDefinitionAtLoc(II: nsEnumId, Loc)) {
1727	FoundationIncluded = true;
1728	return true;
1729	}
1730	edit::Commit commit(*Editor);
1731	if (Ctx.getLangOpts().Modules)
1732	commit.insert(loc: Loc, text: "#ifndef NS_ENUM\n@import Foundation;\n#endif\n");
1733	else
1734	commit.insert(loc: Loc, text: "#ifndef NS_ENUM\n#import <Foundation/Foundation.h>\n#endif\n");
1735	Editor->commit(commit);
1736	FoundationIncluded = true;
1737	return true;
1738	}
1739
1740	namespace {
1741
1742	class RewritesReceiver : public edit::EditsReceiver {
1743	Rewriter &Rewrite;
1744
1745	public:
1746	RewritesReceiver(Rewriter &Rewrite) : Rewrite(Rewrite) { }
1747
1748	void insert(SourceLocation loc, StringRef text) override {
1749	Rewrite.InsertText(Loc: loc, Str: text);
1750	}
1751	void replace(CharSourceRange range, StringRef text) override {
1752	Rewrite.ReplaceText(Start: range.getBegin(), OrigLength: Rewrite.getRangeSize(Range: range), NewStr: text);
1753	}
1754	};
1755
1756	class JSONEditWriter : public edit::EditsReceiver {
1757	SourceManager &SourceMgr;
1758	llvm::raw_ostream &OS;
1759
1760	public:
1761	JSONEditWriter(SourceManager &SM, llvm::raw_ostream &OS)
1762	: SourceMgr(SM), OS(OS) {
1763	OS << "[\n";
1764	}
1765	~JSONEditWriter() override { OS << "]\n"; }
1766
1767	private:
1768	struct EntryWriter {
1769	SourceManager &SourceMgr;
1770	llvm::raw_ostream &OS;
1771
1772	EntryWriter(SourceManager &SM, llvm::raw_ostream &OS)
1773	: SourceMgr(SM), OS(OS) {
1774	OS << " {\n";
1775	}
1776	~EntryWriter() {
1777	OS << " },\n";
1778	}
1779
1780	void writeLoc(SourceLocation Loc) {
1781	FileID FID;
1782	unsigned Offset;
1783	std::tie(args&: FID, args&: Offset) = SourceMgr.getDecomposedLoc(Loc);
1784	assert(FID.isValid());
1785	SmallString<200> Path =
1786	StringRef(SourceMgr.getFileEntryRefForID(FID)->getName());
1787	llvm::sys::fs::make_absolute(path&: Path);
1788	OS << " \"file\": \"";
1789	OS.write_escaped(Str: Path.str()) << "\",\n";
1790	OS << " \"offset\": " << Offset << ",\n";
1791	}
1792
1793	void writeRemove(CharSourceRange Range) {
1794	assert(Range.isCharRange());
1795	std::pair<FileID, unsigned> Begin =
1796	SourceMgr.getDecomposedLoc(Loc: Range.getBegin());
1797	std::pair<FileID, unsigned> End =
1798	SourceMgr.getDecomposedLoc(Loc: Range.getEnd());
1799	assert(Begin.first == End.first);
1800	assert(Begin.second <= End.second);
1801	unsigned Length = End.second - Begin.second;
1802
1803	OS << " \"remove\": " << Length << ",\n";
1804	}
1805
1806	void writeText(StringRef Text) {
1807	OS << " \"text\": \"";
1808	OS.write_escaped(Str: Text) << "\",\n";
1809	}
1810	};
1811
1812	void insert(SourceLocation Loc, StringRef Text) override {
1813	EntryWriter Writer(SourceMgr, OS);
1814	Writer.writeLoc(Loc);
1815	Writer.writeText(Text);
1816	}
1817
1818	void replace(CharSourceRange Range, StringRef Text) override {
1819	EntryWriter Writer(SourceMgr, OS);
1820	Writer.writeLoc(Loc: Range.getBegin());
1821	Writer.writeRemove(Range);
1822	Writer.writeText(Text);
1823	}
1824
1825	void remove(CharSourceRange Range) override {
1826	EntryWriter Writer(SourceMgr, OS);
1827	Writer.writeLoc(Loc: Range.getBegin());
1828	Writer.writeRemove(Range);
1829	}
1830	};
1831
1832	} // end anonymous namespace
1833
1834	void ObjCMigrateASTConsumer::HandleTranslationUnit(ASTContext &Ctx) {
1835
1836	TranslationUnitDecl *TU = Ctx.getTranslationUnitDecl();
1837	if (ASTMigrateActions & FrontendOptions::ObjCMT_MigrateDecls) {
1838	for (DeclContext::decl_iterator D = TU->decls_begin(), DEnd = TU->decls_end();
1839	D != DEnd; ++D) {
1840	FileID FID = PP.getSourceManager().getFileID(SpellingLoc: (*D)->getLocation());
1841	if (FID.isValid())
1842	if (FileId.isValid() && FileId != FID) {
1843	if (ASTMigrateActions & FrontendOptions::ObjCMT_Annotation)
1844	AnnotateImplicitBridging(Ctx);
1845	}
1846
1847	if (ObjCInterfaceDecl *CDecl = dyn_cast<ObjCInterfaceDecl>(Val: *D))
1848	if (canModify(CDecl))
1849	migrateObjCContainerDecl(Ctx, CDecl);
1850	if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(Val: *D)) {
1851	if (canModify(CatDecl))
1852	migrateObjCContainerDecl(Ctx, CatDecl);
1853	}
1854	else if (ObjCProtocolDecl *PDecl = dyn_cast<ObjCProtocolDecl>(Val: *D)) {
1855	ObjCProtocolDecls.insert(Ptr: PDecl->getCanonicalDecl());
1856	if (canModify(PDecl))
1857	migrateObjCContainerDecl(Ctx, PDecl);
1858	}
1859	else if (const ObjCImplementationDecl *ImpDecl =
1860	dyn_cast<ObjCImplementationDecl>(Val: *D)) {
1861	if ((ASTMigrateActions & FrontendOptions::ObjCMT_ProtocolConformance) &&
1862	canModify(ImpDecl))
1863	migrateProtocolConformance(Ctx, ImpDecl);
1864	}
1865	else if (const EnumDecl *ED = dyn_cast<EnumDecl>(Val: *D)) {
1866	if (!(ASTMigrateActions & FrontendOptions::ObjCMT_NsMacros))
1867	continue;
1868	if (!canModify(ED))
1869	continue;
1870	DeclContext::decl_iterator N = D;
1871	if (++N != DEnd) {
1872	const TypedefDecl *TD = dyn_cast<TypedefDecl>(Val: *N);
1873	if (migrateNSEnumDecl(Ctx, EnumDcl: ED, TypedefDcl: TD) && TD)
1874	D++;
1875	}
1876	else
1877	migrateNSEnumDecl(Ctx, EnumDcl: ED, /*TypedefDecl */TypedefDcl: nullptr);
1878	}
1879	else if (const TypedefDecl *TD = dyn_cast<TypedefDecl>(Val: *D)) {
1880	if (!(ASTMigrateActions & FrontendOptions::ObjCMT_NsMacros))
1881	continue;
1882	if (!canModify(TD))
1883	continue;
1884	DeclContext::decl_iterator N = D;
1885	if (++N == DEnd)
1886	continue;
1887	if (const EnumDecl *ED = dyn_cast<EnumDecl>(Val: *N)) {
1888	if (canModify(ED)) {
1889	if (++N != DEnd)
1890	if (const TypedefDecl *TDF = dyn_cast<TypedefDecl>(Val: *N)) {
1891	// prefer typedef-follows-enum to enum-follows-typedef pattern.
1892	if (migrateNSEnumDecl(Ctx, EnumDcl: ED, TypedefDcl: TDF)) {
1893	++D; ++D;
1894	CacheObjCNSIntegerTypedefed(TypedefDcl: TD);
1895	continue;
1896	}
1897	}
1898	if (migrateNSEnumDecl(Ctx, EnumDcl: ED, TypedefDcl: TD)) {
1899	++D;
1900	continue;
1901	}
1902	}
1903	}
1904	CacheObjCNSIntegerTypedefed(TypedefDcl: TD);
1905	}
1906	else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Val: *D)) {
1907	if ((ASTMigrateActions & FrontendOptions::ObjCMT_Annotation) &&
1908	canModify(FD))
1909	migrateCFAnnotation(Ctx, FD);
1910	}
1911
1912	if (ObjCContainerDecl *CDecl = dyn_cast<ObjCContainerDecl>(Val: *D)) {
1913	bool CanModify = canModify(CDecl);
1914	// migrate methods which can have instancetype as their result type.
1915	if ((ASTMigrateActions & FrontendOptions::ObjCMT_Instancetype) &&
1916	CanModify)
1917	migrateAllMethodInstaceType(Ctx, CDecl);
1918	// annotate methods with CF annotations.
1919	if ((ASTMigrateActions & FrontendOptions::ObjCMT_Annotation) &&
1920	CanModify)
1921	migrateARCSafeAnnotation(Ctx, CDecl);
1922	}
1923
1924	if (const ObjCImplementationDecl *
1925	ImplD = dyn_cast<ObjCImplementationDecl>(Val: *D)) {
1926	if ((ASTMigrateActions & FrontendOptions::ObjCMT_DesignatedInitializer) &&
1927	canModify(ImplD))
1928	inferDesignatedInitializers(Ctx, ImplD);
1929	}
1930	}
1931	if (ASTMigrateActions & FrontendOptions::ObjCMT_Annotation)
1932	AnnotateImplicitBridging(Ctx);
1933	}
1934
1935	if (IsOutputFile) {
1936	std::error_code EC;
1937	llvm::raw_fd_ostream OS(MigrateDir, EC, llvm::sys::fs::OF_None);
1938	if (EC) {
1939	DiagnosticsEngine &Diags = Ctx.getDiagnostics();
1940	Diags.Report(DiagID: Diags.getCustomDiagID(L: DiagnosticsEngine::Error, FormatString: "%0"))
1941	<< EC.message();
1942	return;
1943	}
1944
1945	JSONEditWriter Writer(Ctx.getSourceManager(), OS);
1946	Editor->applyRewrites(receiver&: Writer);
1947	return;
1948	}
1949
1950	Rewriter rewriter(Ctx.getSourceManager(), Ctx.getLangOpts());
1951	RewritesReceiver Rec(rewriter);
1952	Editor->applyRewrites(receiver&: Rec);
1953
1954	for (Rewriter::buffer_iterator
1955	I = rewriter.buffer_begin(), E = rewriter.buffer_end(); I != E; ++I) {
1956	FileID FID = I->first;
1957	RewriteBuffer &buf = I->second;
1958	OptionalFileEntryRef file =
1959	Ctx.getSourceManager().getFileEntryRefForID(FID);
1960	assert(file);
1961	SmallString<512> newText;
1962	llvm::raw_svector_ostream vecOS(newText);
1963	buf.write(Stream&: vecOS);
1964	std::unique_ptr<llvm::MemoryBuffer> memBuf(
1965	llvm::MemoryBuffer::getMemBufferCopy(
1966	InputData: StringRef(newText.data(), newText.size()), BufferName: file->getName()));
1967	SmallString<64> filePath(file->getName());
1968	FileMgr.FixupRelativePath(path&: filePath);
1969	Remapper.remap(filePath: filePath.str(), memBuf: std::move(memBuf));
1970	}
1971
1972	if (IsOutputFile) {
1973	Remapper.flushToFile(outputPath: MigrateDir, Diag&: Ctx.getDiagnostics());
1974	} else {
1975	Remapper.flushToDisk(outputDir: MigrateDir, Diag&: Ctx.getDiagnostics());
1976	}
1977	}
1978
1979	bool MigrateSourceAction::BeginInvocation(CompilerInstance &CI) {
1980	CI.getDiagnostics().setIgnoreAllWarnings(true);
1981	return true;
1982	}
1983
1984	static std::vector<std::string> getAllowListFilenames(StringRef DirPath) {
1985	using namespace llvm::sys::fs;
1986	using namespace llvm::sys::path;
1987
1988	std::vector<std::string> Filenames;
1989	if (DirPath.empty() || !is_directory(Path: DirPath))
1990	return Filenames;
1991
1992	std::error_code EC;
1993	directory_iterator DI = directory_iterator(DirPath, EC);
1994	directory_iterator DE;
1995	for (; !EC && DI != DE; DI = DI.increment(ec&: EC)) {
1996	if (is_regular_file(Path: DI->path()))
1997	Filenames.push_back(x: std::string(filename(path: DI->path())));
1998	}
1999
2000	return Filenames;
2001	}
2002
2003	std::unique_ptr<ASTConsumer>
2004	MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
2005	PPConditionalDirectiveRecord *
2006	PPRec = new PPConditionalDirectiveRecord(CI.getSourceManager());
2007	unsigned ObjCMTAction = CI.getFrontendOpts().ObjCMTAction;
2008	unsigned ObjCMTOpts = ObjCMTAction;
2009	// These are companion flags, they do not enable transformations.
2010	ObjCMTOpts &= ~(FrontendOptions::ObjCMT_AtomicProperty |
2011	FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty);
2012	if (ObjCMTOpts == FrontendOptions::ObjCMT_None) {
2013	// If no specific option was given, enable literals+subscripting transforms
2014	// by default.
2015	ObjCMTAction |=
2016	FrontendOptions::ObjCMT_Literals | FrontendOptions::ObjCMT_Subscripting;
2017	}
2018	CI.getPreprocessor().addPPCallbacks(C: std::unique_ptr<PPCallbacks>(PPRec));
2019	std::vector<std::string> AllowList =
2020	getAllowListFilenames(DirPath: CI.getFrontendOpts().ObjCMTAllowListPath);
2021	return std::make_unique<ObjCMigrateASTConsumer>(
2022	args&: CI.getFrontendOpts().OutputFile, args&: ObjCMTAction, args&: Remapper,
2023	args&: CI.getFileManager(), args&: PPRec, args&: CI.getPreprocessor(),
2024	/*isOutputFile=*/args: true, args&: AllowList);
2025	}
2026
2027	namespace {
2028	struct EditEntry {
2029	OptionalFileEntryRef File;
2030	unsigned Offset = 0;
2031	unsigned RemoveLen = 0;
2032	std::string Text;
2033	};
2034	} // end anonymous namespace
2035
2036	namespace llvm {
2037	template<> struct DenseMapInfo<EditEntry> {
2038	static inline EditEntry getEmptyKey() {
2039	EditEntry Entry;
2040	Entry.Offset = unsigned(-1);
2041	return Entry;
2042	}
2043	static inline EditEntry getTombstoneKey() {
2044	EditEntry Entry;
2045	Entry.Offset = unsigned(-2);
2046	return Entry;
2047	}
2048	static unsigned getHashValue(const EditEntry& Val) {
2049	return (unsigned)llvm::hash_combine(args: Val.File, args: Val.Offset, args: Val.RemoveLen,
2050	args: Val.Text);
2051	}
2052	static bool isEqual(const EditEntry &LHS, const EditEntry &RHS) {
2053	return LHS.File == RHS.File &&
2054	LHS.Offset == RHS.Offset &&
2055	LHS.RemoveLen == RHS.RemoveLen &&
2056	LHS.Text == RHS.Text;
2057	}
2058	};
2059	} // end namespace llvm
2060
2061	namespace {
2062	class RemapFileParser {
2063	FileManager &FileMgr;
2064
2065	public:
2066	RemapFileParser(FileManager &FileMgr) : FileMgr(FileMgr) { }
2067
2068	bool parse(StringRef File, SmallVectorImpl<EditEntry> &Entries) {
2069	using namespace llvm::yaml;
2070
2071	llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileBufOrErr =
2072	llvm::MemoryBuffer::getFile(Filename: File);
2073	if (!FileBufOrErr)
2074	return true;
2075
2076	llvm::SourceMgr SM;
2077	Stream YAMLStream(FileBufOrErr.get()->getMemBufferRef(), SM);
2078	document_iterator I = YAMLStream.begin();
2079	if (I == YAMLStream.end())
2080	return true;
2081	Node *Root = I->getRoot();
2082	if (!Root)
2083	return true;
2084
2085	SequenceNode *SeqNode = dyn_cast<SequenceNode>(Val: Root);
2086	if (!SeqNode)
2087	return true;
2088
2089	for (SequenceNode::iterator
2090	AI = SeqNode->begin(), AE = SeqNode->end(); AI != AE; ++AI) {
2091	MappingNode *MapNode = dyn_cast<MappingNode>(Val: &*AI);
2092	if (!MapNode)
2093	continue;
2094	parseEdit(Node: MapNode, Entries);
2095	}
2096
2097	return false;
2098	}
2099
2100	private:
2101	void parseEdit(llvm::yaml::MappingNode *Node,
2102	SmallVectorImpl<EditEntry> &Entries) {
2103	using namespace llvm::yaml;
2104	EditEntry Entry;
2105	bool Ignore = false;
2106
2107	for (MappingNode::iterator
2108	KVI = Node->begin(), KVE = Node->end(); KVI != KVE; ++KVI) {
2109	ScalarNode *KeyString = dyn_cast<ScalarNode>(Val: (*KVI).getKey());
2110	if (!KeyString)
2111	continue;
2112	SmallString<10> KeyStorage;
2113	StringRef Key = KeyString->getValue(Storage&: KeyStorage);
2114
2115	ScalarNode *ValueString = dyn_cast<ScalarNode>(Val: (*KVI).getValue());
2116	if (!ValueString)
2117	continue;
2118	SmallString<64> ValueStorage;
2119	StringRef Val = ValueString->getValue(Storage&: ValueStorage);
2120
2121	if (Key == "file") {
2122	if (auto File = FileMgr.getOptionalFileRef(Filename: Val))
2123	Entry.File = File;
2124	else
2125	Ignore = true;
2126	} else if (Key == "offset") {
2127	if (Val.getAsInteger(Radix: 10, Result&: Entry.Offset))
2128	Ignore = true;
2129	} else if (Key == "remove") {
2130	if (Val.getAsInteger(Radix: 10, Result&: Entry.RemoveLen))
2131	Ignore = true;
2132	} else if (Key == "text") {
2133	Entry.Text = std::string(Val);
2134	}
2135	}
2136
2137	if (!Ignore)
2138	Entries.push_back(Elt: Entry);
2139	}
2140	};
2141	} // end anonymous namespace
2142
2143	static bool reportDiag(const Twine &Err, DiagnosticsEngine &Diag) {
2144	Diag.Report(DiagID: Diag.getCustomDiagID(L: DiagnosticsEngine::Error, FormatString: "%0"))
2145	<< Err.str();
2146	return true;
2147	}
2148
2149	static std::string applyEditsToTemp(FileEntryRef FE,
2150	ArrayRef<EditEntry> Edits,
2151	FileManager &FileMgr,
2152	DiagnosticsEngine &Diag) {
2153	using namespace llvm::sys;
2154
2155	SourceManager SM(Diag, FileMgr);
2156	FileID FID = SM.createFileID(SourceFile: FE, IncludePos: SourceLocation(), FileCharacter: SrcMgr::C_User);
2157	LangOptions LangOpts;
2158	edit::EditedSource Editor(SM, LangOpts);
2159	for (ArrayRef<EditEntry>::iterator
2160	I = Edits.begin(), E = Edits.end(); I != E; ++I) {
2161	const EditEntry &Entry = *I;
2162	assert(Entry.File == FE);
2163	SourceLocation Loc =
2164	SM.getLocForStartOfFile(FID).getLocWithOffset(Offset: Entry.Offset);
2165	CharSourceRange Range;
2166	if (Entry.RemoveLen != 0) {
2167	Range = CharSourceRange::getCharRange(B: Loc,
2168	E: Loc.getLocWithOffset(Offset: Entry.RemoveLen));
2169	}
2170
2171	edit::Commit commit(Editor);
2172	if (Range.isInvalid()) {
2173	commit.insert(loc: Loc, text: Entry.Text);
2174	} else if (Entry.Text.empty()) {
2175	commit.remove(range: Range);
2176	} else {
2177	commit.replace(range: Range, text: Entry.Text);
2178	}
2179	Editor.commit(commit);
2180	}
2181
2182	Rewriter rewriter(SM, LangOpts);
2183	RewritesReceiver Rec(rewriter);
2184	Editor.applyRewrites(receiver&: Rec, /*adjustRemovals=*/false);
2185
2186	const RewriteBuffer *Buf = rewriter.getRewriteBufferFor(FID);
2187	SmallString<512> NewText;
2188	llvm::raw_svector_ostream OS(NewText);
2189	Buf->write(Stream&: OS);
2190
2191	SmallString<64> TempPath;
2192	int FD;
2193	if (fs::createTemporaryFile(Prefix: path::filename(path: FE.getName()),
2194	Suffix: path::extension(path: FE.getName()).drop_front(), ResultFD&: FD,
2195	ResultPath&: TempPath)) {
2196	reportDiag(Err: "Could not create file: " + TempPath.str(), Diag);
2197	return std::string();
2198	}
2199
2200	llvm::raw_fd_ostream TmpOut(FD, /*shouldClose=*/true);
2201	TmpOut.write(Ptr: NewText.data(), Size: NewText.size());
2202	TmpOut.close();
2203
2204	return std::string(TempPath);
2205	}
2206
2207	bool arcmt::getFileRemappingsFromFileList(
2208	std::vector<std::pair<std::string,std::string> > &remap,
2209	ArrayRef<StringRef> remapFiles,
2210	DiagnosticConsumer *DiagClient) {
2211	bool hasErrorOccurred = false;
2212
2213	FileSystemOptions FSOpts;
2214	FileManager FileMgr(FSOpts);
2215	RemapFileParser Parser(FileMgr);
2216
2217	IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
2218	IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
2219	new DiagnosticsEngine(DiagID, new DiagnosticOptions,
2220	DiagClient, /*ShouldOwnClient=*/false));
2221
2222	typedef llvm::DenseMap<FileEntryRef, std::vector<EditEntry> >
2223	FileEditEntriesTy;
2224	FileEditEntriesTy FileEditEntries;
2225
2226	llvm::DenseSet<EditEntry> EntriesSet;
2227
2228	for (ArrayRef<StringRef>::iterator
2229	I = remapFiles.begin(), E = remapFiles.end(); I != E; ++I) {
2230	SmallVector<EditEntry, 16> Entries;
2231	if (Parser.parse(File: *I, Entries))
2232	continue;
2233
2234	for (SmallVectorImpl<EditEntry>::iterator
2235	EI = Entries.begin(), EE = Entries.end(); EI != EE; ++EI) {
2236	EditEntry &Entry = *EI;
2237	if (!Entry.File)
2238	continue;
2239	std::pair<llvm::DenseSet<EditEntry>::iterator, bool>
2240	Insert = EntriesSet.insert(V: Entry);
2241	if (!Insert.second)
2242	continue;
2243
2244	FileEditEntries[*Entry.File].push_back(x: Entry);
2245	}
2246	}
2247
2248	for (FileEditEntriesTy::iterator
2249	I = FileEditEntries.begin(), E = FileEditEntries.end(); I != E; ++I) {
2250	std::string TempFile = applyEditsToTemp(FE: I->first, Edits: I->second,
2251	FileMgr, Diag&: *Diags);
2252	if (TempFile.empty()) {
2253	hasErrorOccurred = true;
2254	continue;
2255	}
2256
2257	remap.emplace_back(args: std::string(I->first.getName()), args&: TempFile);
2258	}
2259
2260	return hasErrorOccurred;
2261	}
2262