SelectorLocationsKind.cpp source code [clang_source_code/lib/AST/SelectorLocationsKind.cpp]

1	//===--- SelectorLocationsKind.cpp - Kind of selector locations -- C++ --===//
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	// Describes whether the identifier locations for a selector are "standard"
10	// or not.
11	//
12	//===----------------------------------------------------------------------===//
13
14	#include "clang/AST/SelectorLocationsKind.h"
15	#include "clang/AST/Expr.h"
16
17	using namespace clang;
18
19	static SourceLocation getStandardSelLoc(unsigned Index,
20	Selector Sel,
21	bool WithArgSpace,
22	SourceLocation ArgLoc,
23	SourceLocation EndLoc) {
24	unsigned NumSelArgs = Sel.getNumArgs();
25	if (NumSelArgs == 0) {
26	assert(Index == 0);
27	if (EndLoc.isInvalid())
28	return SourceLocation();
29	IdentifierInfo *II = Sel.getIdentifierInfoForSlot(0);
30	unsigned Len = II ? II->getLength() : 0;
31	return EndLoc.getLocWithOffset(-Len);
32	}
33
34	assert(Index < NumSelArgs);
35	if (ArgLoc.isInvalid())
36	return SourceLocation();
37	IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Index);
38	unsigned Len = /* selector id / (II ? II->getLength() : 0) + / ':' */ 1;
39	if (WithArgSpace)
40	++Len;
41	return ArgLoc.getLocWithOffset(-Len);
42	}
43
44	namespace {
45
46	template <typename T>
47	SourceLocation getArgLoc(T* Arg);
48
49	template <>
50	SourceLocation getArgLoc<Expr>(Expr *Arg) {
51	return Arg->getBeginLoc();
52	}
53
54	template <>
55	SourceLocation getArgLoc<ParmVarDecl>(ParmVarDecl *Arg) {
56	SourceLocation Loc = Arg->getBeginLoc();
57	if (Loc.isInvalid())
58	return Loc;
59	// -1 to point to left paren of the method parameter's type.
60	return Loc.getLocWithOffset(-1);
61	}
62
63	template <typename T>
64	SourceLocation getArgLoc(unsigned Index, ArrayRef<T*> Args) {
65	return Index < Args.size() ? getArgLoc(Args[Index]) : SourceLocation();
66	}
67
68	template <typename T>
69	SelectorLocationsKind hasStandardSelLocs(Selector Sel,
70	ArrayRef<SourceLocation> SelLocs,
71	ArrayRef<T *> Args,
72	SourceLocation EndLoc) {
73	// Are selector locations in standard position with no space between args ?
74	unsigned i;
75	for (i = 0; i != SelLocs.size(); ++i) {
76	if (SelLocs[i] != getStandardSelectorLoc(i, Sel, /WithArgSpace=/false,
77	Args, EndLoc))
78	break;
79	}
80	if (i == SelLocs.size())
81	return SelLoc_StandardNoSpace;
82
83	// Are selector locations in standard position with space between args ?
84	for (i = 0; i != SelLocs.size(); ++i) {
85	if (SelLocs[i] != getStandardSelectorLoc(i, Sel, /WithArgSpace=/true,
86	Args, EndLoc))
87	return SelLoc_NonStandard;
88	}
89
90	return SelLoc_StandardWithSpace;
91	}
92
93	} // anonymous namespace
94
95	SelectorLocationsKind
96	clang::hasStandardSelectorLocs(Selector Sel,
97	ArrayRef<SourceLocation> SelLocs,
98	ArrayRef<Expr *> Args,
99	SourceLocation EndLoc) {
100	return hasStandardSelLocs(Sel, SelLocs, Args, EndLoc);
101	}
102
103	SourceLocation clang::getStandardSelectorLoc(unsigned Index,
104	Selector Sel,
105	bool WithArgSpace,
106	ArrayRef<Expr *> Args,
107	SourceLocation EndLoc) {
108	return getStandardSelLoc(Index, Sel, WithArgSpace,
109	getArgLoc(Index, Args), EndLoc);
110	}
111
112	SelectorLocationsKind
113	clang::hasStandardSelectorLocs(Selector Sel,
114	ArrayRef<SourceLocation> SelLocs,
115	ArrayRef<ParmVarDecl *> Args,
116	SourceLocation EndLoc) {
117	return hasStandardSelLocs(Sel, SelLocs, Args, EndLoc);
118	}
119
120	SourceLocation clang::getStandardSelectorLoc(unsigned Index,
121	Selector Sel,
122	bool WithArgSpace,
123	ArrayRef<ParmVarDecl *> Args,
124	SourceLocation EndLoc) {
125	return getStandardSelLoc(Index, Sel, WithArgSpace,
126	getArgLoc(Index, Args), EndLoc);
127	}
128

Clang Project