Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019, The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Steven Moreland | 9fccf58 | 2018-08-27 20:36:27 -0700 | [diff] [blame] | 17 | #pragma once |
Christopher Wiley | ec31a05 | 2016-01-25 07:28:51 -0800 | [diff] [blame] | 18 | |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 19 | #include <memory> |
Jeongik Cha | 997281d | 2020-01-16 15:23:59 +0900 | [diff] [blame] | 20 | #include <regex> |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 21 | #include <string> |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 22 | #include <unordered_set> |
Jooyung Han | aeb0167 | 2021-11-30 17:29:22 +0900 | [diff] [blame] | 23 | #include <variant> |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 24 | #include <vector> |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 25 | |
Thiébaud Weksteen | 9ab5912 | 2021-09-20 09:37:38 +0200 | [diff] [blame] | 26 | #include <android-base/result.h> |
Elliott Hughes | 0a62067 | 2015-12-04 13:53:18 -0800 | [diff] [blame] | 27 | #include <android-base/strings.h> |
Casey Dahlin | 73d46b0 | 2015-09-11 02:47:54 +0000 | [diff] [blame] | 28 | |
Jooyung Han | 888c5bc | 2020-12-22 17:28:47 +0900 | [diff] [blame] | 29 | #include "aidl_typenames.h" |
| 30 | #include "code_writer.h" |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 31 | #include "comments.h" |
Jooyung Han | 888c5bc | 2020-12-22 17:28:47 +0900 | [diff] [blame] | 32 | #include "diagnostics.h" |
| 33 | #include "io_delegate.h" |
Jooyung Han | 535c5e8 | 2020-12-29 15:16:59 +0900 | [diff] [blame] | 34 | #include "location.h" |
| 35 | #include "logging.h" |
Jooyung Han | 888c5bc | 2020-12-22 17:28:47 +0900 | [diff] [blame] | 36 | #include "options.h" |
Thiébaud Weksteen | 65281c4 | 2021-12-15 10:07:10 +1100 | [diff] [blame] | 37 | #include "permission.h" |
Jooyung Han | 888c5bc | 2020-12-22 17:28:47 +0900 | [diff] [blame] | 38 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 39 | using android::aidl::AidlTypenames; |
Jiyong Park | 02da742 | 2018-07-16 16:00:26 +0900 | [diff] [blame] | 40 | using android::aidl::CodeWriter; |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 41 | using android::aidl::Comments; |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 42 | using android::aidl::Options; |
Thiébaud Weksteen | 9ab5912 | 2021-09-20 09:37:38 +0200 | [diff] [blame] | 43 | using android::base::Result; |
Steven Moreland | 3f658cf | 2018-08-20 13:40:54 -0700 | [diff] [blame] | 44 | using std::shared_ptr; |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 45 | using std::string; |
| 46 | using std::unique_ptr; |
| 47 | using std::vector; |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 48 | class AidlNode; |
| 49 | |
Jooyung Han | 535c5e8 | 2020-12-29 15:16:59 +0900 | [diff] [blame] | 50 | // helper to see if T is the same to one of Args types. |
| 51 | template <typename T, typename... Args> |
| 52 | struct is_one_of : std::false_type {}; |
| 53 | |
| 54 | template <typename T, typename S, typename... Args> |
| 55 | struct is_one_of<T, S, Args...> { |
| 56 | enum { value = std::is_same_v<T, S> || is_one_of<T, Args...>::value }; |
| 57 | }; |
| 58 | |
| 59 | // helper to see if T is std::vector of something. |
| 60 | template <typename> |
| 61 | struct is_vector : std::false_type {}; |
| 62 | |
| 63 | template <typename T> |
| 64 | struct is_vector<std::vector<T>> : std::true_type {}; |
| 65 | |
| 66 | // helper for static_assert(false) |
| 67 | template <typename T> |
| 68 | struct unsupported_type : std::false_type {}; |
| 69 | |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 70 | namespace android { |
| 71 | namespace aidl { |
| 72 | namespace mappings { |
| 73 | std::string dump_location(const AidlNode& method); |
| 74 | } // namespace mappings |
Mathew Inwood | adb7467 | 2019-11-29 14:01:53 +0000 | [diff] [blame] | 75 | namespace java { |
| 76 | std::string dump_location(const AidlNode& method); |
| 77 | } // namespace java |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 78 | } // namespace aidl |
| 79 | } // namespace android |
| 80 | |
Jooyung Han | 535c5e8 | 2020-12-29 15:16:59 +0900 | [diff] [blame] | 81 | bool ParseFloating(std::string_view sv, double* parsed); |
| 82 | bool ParseFloating(std::string_view sv, float* parsed); |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 83 | |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 84 | class AidlDocument; |
| 85 | class AidlInterface; |
| 86 | class AidlParcelable; |
| 87 | class AidlStructuredParcelable; |
| 88 | class AidlEnumDeclaration; |
| 89 | class AidlUnionDecl; |
| 90 | class AidlVariableDeclaration; |
| 91 | class AidlConstantDeclaration; |
| 92 | class AidlEnumerator; |
| 93 | class AidlMethod; |
| 94 | class AidlArgument; |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 95 | class AidlConstantValue; |
| 96 | class AidlConstantReference; |
| 97 | class AidlUnaryConstExpression; |
| 98 | class AidlBinaryConstExpression; |
| 99 | class AidlAnnotation; |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 100 | |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 101 | // Interface for visitors that can traverse AidlTraversable nodes. |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 102 | class AidlVisitor { |
| 103 | public: |
| 104 | virtual ~AidlVisitor() = default; |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 105 | virtual void Visit(const AidlDocument&) {} |
| 106 | virtual void Visit(const AidlInterface&) {} |
| 107 | virtual void Visit(const AidlParcelable&) {} |
| 108 | virtual void Visit(const AidlStructuredParcelable&) {} |
| 109 | virtual void Visit(const AidlUnionDecl&) {} |
| 110 | virtual void Visit(const AidlEnumDeclaration&) {} |
| 111 | virtual void Visit(const AidlEnumerator&) {} |
| 112 | virtual void Visit(const AidlMethod&) {} |
| 113 | virtual void Visit(const AidlVariableDeclaration&) {} |
| 114 | virtual void Visit(const AidlConstantDeclaration&) {} |
| 115 | virtual void Visit(const AidlArgument&) {} |
Jooyung Han | 865da49 | 2021-01-03 11:32:47 +0900 | [diff] [blame] | 116 | virtual void Visit(const AidlTypeSpecifier&) {} |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 117 | virtual void Visit(const AidlConstantValue&) {} |
| 118 | virtual void Visit(const AidlConstantReference&) {} |
| 119 | virtual void Visit(const AidlUnaryConstExpression&) {} |
| 120 | virtual void Visit(const AidlBinaryConstExpression&) {} |
| 121 | virtual void Visit(const AidlAnnotation&) {} |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 122 | }; |
| 123 | |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 124 | class AidlScope { |
| 125 | public: |
Jooyung Han | 3578498 | 2021-06-29 06:26:12 +0900 | [diff] [blame] | 126 | AidlScope(const AidlNode* self) : self_(self) {} |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 127 | virtual ~AidlScope() = default; |
| 128 | virtual std::string ResolveName(const std::string& name) const = 0; |
| 129 | void SetEnclosingScope(const AidlScope* enclosing) { |
| 130 | AIDL_FATAL_IF(enclosing_, AIDL_LOCATION_HERE) << "SetEnclosingScope can be set only once."; |
| 131 | enclosing_ = enclosing; |
| 132 | } |
| 133 | const AidlScope* GetEnclosingScope() const { return enclosing_; } |
Jooyung Han | 3578498 | 2021-06-29 06:26:12 +0900 | [diff] [blame] | 134 | const AidlNode& GetNode() const { return *self_; } |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 135 | |
| 136 | private: |
Jooyung Han | 3578498 | 2021-06-29 06:26:12 +0900 | [diff] [blame] | 137 | const AidlNode* self_; |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 138 | const AidlScope* enclosing_ = nullptr; |
| 139 | }; |
| 140 | |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 141 | // Anything that is locatable in a .aidl file. |
| 142 | class AidlNode { |
| 143 | public: |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 144 | AidlNode(const AidlLocation& location, const Comments& comments = {}); |
Steven Moreland | 3f658cf | 2018-08-20 13:40:54 -0700 | [diff] [blame] | 145 | |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 146 | virtual ~AidlNode(); |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 147 | |
Steven Moreland | a7560e8 | 2021-10-08 16:24:39 -0700 | [diff] [blame] | 148 | AidlNode(AidlNode&) = delete; |
| 149 | AidlNode& operator=(AidlNode&) = delete; |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 150 | AidlNode(AidlNode&&) = delete; |
| 151 | AidlNode& operator=(AidlNode&&) = delete; |
| 152 | |
Devin Moore | df93ebb | 2020-03-25 14:03:35 -0700 | [diff] [blame] | 153 | // To be able to print AidlLocation |
Steven Moreland | b0d15a5 | 2020-03-31 14:03:47 -0700 | [diff] [blame] | 154 | friend class AidlErrorLog; |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 155 | friend std::string android::aidl::mappings::dump_location(const AidlNode&); |
Mathew Inwood | adb7467 | 2019-11-29 14:01:53 +0000 | [diff] [blame] | 156 | friend std::string android::aidl::java::dump_location(const AidlNode&); |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 157 | |
Devin Moore | df93ebb | 2020-03-25 14:03:35 -0700 | [diff] [blame] | 158 | const AidlLocation& GetLocation() const { return location_; } |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 159 | virtual void TraverseChildren(std::function<void(const AidlNode&)> traverse) const = 0; |
| 160 | virtual void DispatchVisit(AidlVisitor&) const = 0; |
Devin Moore | df93ebb | 2020-03-25 14:03:35 -0700 | [diff] [blame] | 161 | |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 162 | const Comments& GetComments() const { return comments_; } |
| 163 | void SetComments(const Comments& comments) { comments_ = comments; } |
Jooyung Han | 5c7e77c | 2021-01-20 16:00:29 +0900 | [diff] [blame] | 164 | |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 165 | static void ClearUnvisitedNodes(); |
| 166 | static const std::vector<AidlLocation>& GetLocationsOfUnvisitedNodes(); |
| 167 | void MarkVisited() const; |
Jooyung Han | ae01675 | 2022-02-26 21:33:43 +0900 | [diff] [blame] | 168 | bool IsUserDefined() const { return !GetLocation().IsInternal(); } |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 169 | |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 170 | private: |
Mathew Inwood | adb7467 | 2019-11-29 14:01:53 +0000 | [diff] [blame] | 171 | std::string PrintLine() const; |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 172 | std::string PrintLocation() const; |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 173 | const AidlLocation location_; |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 174 | Comments comments_; |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 175 | |
| 176 | // make sure we are able to abort if types are not visited |
| 177 | mutable bool visited_ = false; |
| 178 | static std::vector<AidlLocation> unvisited_locations_; |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 179 | }; |
| 180 | |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 181 | // unique_ptr<AidlTypeSpecifier> for type arugment, |
| 182 | // std::string for type parameter(T, U, and so on). |
| 183 | template <typename T> |
| 184 | class AidlParameterizable { |
| 185 | public: |
| 186 | AidlParameterizable(std::vector<T>* type_params) : type_params_(type_params) {} |
| 187 | virtual ~AidlParameterizable() = default; |
| 188 | bool IsGeneric() const { return type_params_ != nullptr; } |
| 189 | const std::vector<T>& GetTypeParameters() const { return *type_params_; } |
| 190 | bool CheckValid() const; |
| 191 | |
Steven Moreland | 6c07b83 | 2020-10-29 23:39:53 +0000 | [diff] [blame] | 192 | __attribute__((warn_unused_result)) bool SetTypeParameters(std::vector<T>* type_params) { |
| 193 | if (type_params_) return false; |
| 194 | type_params_.reset(type_params); |
| 195 | return true; |
| 196 | } |
| 197 | |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 198 | virtual const AidlNode& AsAidlNode() const = 0; |
| 199 | |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 200 | private: |
Steven Moreland | 6c07b83 | 2020-10-29 23:39:53 +0000 | [diff] [blame] | 201 | unique_ptr<std::vector<T>> type_params_; |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 202 | static_assert(std::is_same<T, unique_ptr<AidlTypeSpecifier>>::value || |
| 203 | std::is_same<T, std::string>::value); |
| 204 | }; |
| 205 | template <> |
| 206 | bool AidlParameterizable<std::string>::CheckValid() const; |
| 207 | |
Jooyung Han | 5c7e77c | 2021-01-20 16:00:29 +0900 | [diff] [blame] | 208 | class AidlCommentable : public AidlNode { |
Jooyung Han | 6736ffb | 2021-01-16 10:13:40 +0900 | [diff] [blame] | 209 | public: |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 210 | AidlCommentable(const AidlLocation& location, const Comments& comments) |
Jooyung Han | 5c7e77c | 2021-01-20 16:00:29 +0900 | [diff] [blame] | 211 | : AidlNode(location, comments) {} |
Jooyung Han | 6736ffb | 2021-01-16 10:13:40 +0900 | [diff] [blame] | 212 | virtual ~AidlCommentable() = default; |
| 213 | |
Jooyung Han | 6736ffb | 2021-01-16 10:13:40 +0900 | [diff] [blame] | 214 | bool IsHidden() const; |
| 215 | bool IsDeprecated() const; |
Jooyung Han | 6736ffb | 2021-01-16 10:13:40 +0900 | [diff] [blame] | 216 | }; |
Andrei Onea | 9445fc6 | 2019-06-27 18:11:59 +0100 | [diff] [blame] | 217 | |
| 218 | // Transforms a value string into a language specific form. Raw value as produced by |
| 219 | // AidlConstantValue. |
Jooyung Han | aeb0167 | 2021-11-30 17:29:22 +0900 | [diff] [blame] | 220 | using ConstantValueDecorator = std::function<std::string( |
| 221 | const AidlTypeSpecifier& type, |
| 222 | const std::variant<std::string, std::vector<std::string>>& raw_value)>; |
Andrei Onea | 9445fc6 | 2019-06-27 18:11:59 +0100 | [diff] [blame] | 223 | |
Jooyung Han | 5c7e77c | 2021-01-20 16:00:29 +0900 | [diff] [blame] | 224 | class AidlAnnotation : public AidlNode { |
Jiyong Park | 68bc77a | 2018-07-19 19:00:45 +0900 | [diff] [blame] | 225 | public: |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 226 | enum class Type { |
| 227 | BACKING = 1, |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 228 | JAVA_STABLE_PARCELABLE, |
| 229 | UNSUPPORTED_APP_USAGE, |
| 230 | VINTF_STABILITY, |
| 231 | NULLABLE, |
| 232 | UTF8_IN_CPP, |
Steven Moreland | a7764e5 | 2020-10-27 17:29:29 +0000 | [diff] [blame] | 233 | SENSITIVE_DATA, |
Jiyong Park | bf5fd5c | 2020-06-05 19:48:05 +0900 | [diff] [blame] | 234 | JAVA_PASSTHROUGH, |
Jooyung Han | 9034500 | 2020-10-23 15:28:53 +0900 | [diff] [blame] | 235 | JAVA_DERIVE, |
Hao Ke | 2a46d06 | 2021-11-11 19:40:56 +0000 | [diff] [blame] | 236 | JAVA_DEFAULT, |
Devin Moore | 14ca7d9 | 2022-02-02 00:00:35 +0000 | [diff] [blame] | 237 | JAVA_DELEGATOR, |
Jeongik Cha | d0a1027 | 2020-08-06 16:33:36 +0900 | [diff] [blame] | 238 | JAVA_ONLY_IMMUTABLE, |
Jooyung Han | c2bc750 | 2022-01-18 16:00:51 +0900 | [diff] [blame] | 239 | JAVA_SUPPRESS_LINT, |
Devin Moore | c7e47a3 | 2020-08-07 10:55:25 -0700 | [diff] [blame] | 240 | FIXED_SIZE, |
Jiyong Park | 27fd7fd | 2020-08-27 16:25:09 +0900 | [diff] [blame] | 241 | DESCRIPTOR, |
Andrei Homescu | e61feb5 | 2020-08-18 15:44:24 -0700 | [diff] [blame] | 242 | RUST_DERIVE, |
Jooyung Han | f8dbbcc | 2020-12-26 03:05:55 +0900 | [diff] [blame] | 243 | SUPPRESS_WARNINGS, |
Thiébaud Weksteen | e79243a | 2021-11-02 14:36:25 +1100 | [diff] [blame] | 244 | PERMISSION_ENFORCE, |
| 245 | PERMISSION_NONE, |
Makoto Onuki | 23edf92 | 2022-01-27 16:29:55 -0800 | [diff] [blame] | 246 | PERMISSION_MANUAL, |
| 247 | PROPAGATE_ALLOW_BLOCKING, |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 248 | }; |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 249 | |
| 250 | using TargetContext = uint16_t; |
| 251 | static constexpr TargetContext CONTEXT_TYPE_INTERFACE = 0x1 << 0; |
| 252 | static constexpr TargetContext CONTEXT_TYPE_ENUM = 0x1 << 1; |
| 253 | static constexpr TargetContext CONTEXT_TYPE_STRUCTURED_PARCELABLE = 0x1 << 2; |
| 254 | static constexpr TargetContext CONTEXT_TYPE_UNION = 0x1 << 3; |
| 255 | static constexpr TargetContext CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE = 0x1 << 4; |
| 256 | static constexpr TargetContext CONTEXT_TYPE = |
| 257 | CONTEXT_TYPE_INTERFACE | CONTEXT_TYPE_ENUM | CONTEXT_TYPE_STRUCTURED_PARCELABLE | |
| 258 | CONTEXT_TYPE_UNION | CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE; |
| 259 | static constexpr TargetContext CONTEXT_CONST = 0x1 << 5; |
| 260 | static constexpr TargetContext CONTEXT_FIELD = 0x1 << 6; |
| 261 | static constexpr TargetContext CONTEXT_METHOD = 0x1 << 7; |
| 262 | static constexpr TargetContext CONTEXT_MEMBER = CONTEXT_CONST | CONTEXT_FIELD | CONTEXT_METHOD; |
| 263 | static constexpr TargetContext CONTEXT_TYPE_SPECIFIER = 0x1 << 8; |
| 264 | static constexpr TargetContext CONTEXT_ALL = |
| 265 | CONTEXT_TYPE | CONTEXT_MEMBER | CONTEXT_TYPE_SPECIFIER; |
| 266 | |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 267 | static std::string TypeToString(Type type); |
| 268 | |
Jooyung Han | 442cacf | 2021-09-13 17:44:56 +0900 | [diff] [blame] | 269 | static std::unique_ptr<AidlAnnotation> Parse( |
Andrei Onea | 9445fc6 | 2019-06-27 18:11:59 +0100 | [diff] [blame] | 270 | const AidlLocation& location, const string& name, |
Jooyung Han | 442cacf | 2021-09-13 17:44:56 +0900 | [diff] [blame] | 271 | std::map<std::string, std::shared_ptr<AidlConstantValue>> parameter_list, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 272 | const Comments& comments); |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 273 | |
Steven Moreland | 3be7577 | 2018-08-20 13:27:43 -0700 | [diff] [blame] | 274 | AidlAnnotation(AidlAnnotation&&) = default; |
Jiyong Park | 68bc77a | 2018-07-19 19:00:45 +0900 | [diff] [blame] | 275 | virtual ~AidlAnnotation() = default; |
Andrei Onea | 9445fc6 | 2019-06-27 18:11:59 +0100 | [diff] [blame] | 276 | bool CheckValid() const; |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 277 | bool CheckContext(TargetContext context) const; |
Jooyung Han | d902a97 | 2020-10-23 17:32:44 +0900 | [diff] [blame] | 278 | const string& GetName() const { return schema_.name; } |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 279 | const Type& GetType() const { return schema_.type; } |
Jooyung Han | d902a97 | 2020-10-23 17:32:44 +0900 | [diff] [blame] | 280 | bool Repeatable() const { return schema_.repeatable; } |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 281 | |
| 282 | // ToString is for dumping AIDL. |
| 283 | // Returns string representation of this annotation. |
| 284 | // e.g) "@RustDerive(Clone=true, Copy=true)" |
| 285 | string ToString() const; |
| 286 | |
Jooyung Han | b3c77ed | 2020-12-26 02:02:45 +0900 | [diff] [blame] | 287 | template <typename T> |
| 288 | std::optional<T> ParamValue(const std::string& param_name) const; |
| 289 | |
Andrei Onea | 9445fc6 | 2019-06-27 18:11:59 +0100 | [diff] [blame] | 290 | std::map<std::string, std::string> AnnotationParams( |
| 291 | const ConstantValueDecorator& decorator) const; |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 292 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override; |
| 293 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jiyong Park | 68bc77a | 2018-07-19 19:00:45 +0900 | [diff] [blame] | 294 | |
Thiébaud Weksteen | 65281c4 | 2021-12-15 10:07:10 +1100 | [diff] [blame] | 295 | Result<unique_ptr<android::aidl::perm::Expression>> EnforceExpression() const; |
Thiébaud Weksteen | 9ab5912 | 2021-09-20 09:37:38 +0200 | [diff] [blame] | 296 | |
Jiyong Park | 68bc77a | 2018-07-19 19:00:45 +0900 | [diff] [blame] | 297 | private: |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 298 | struct ParamType { |
| 299 | std::string name; |
| 300 | const AidlTypeSpecifier& type; |
| 301 | bool required = false; |
| 302 | }; |
| 303 | |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 304 | struct Schema { |
| 305 | AidlAnnotation::Type type; |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 306 | std::string name; |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 307 | TargetContext target_context; |
| 308 | std::vector<ParamType> parameters; |
| 309 | bool repeatable = false; |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 310 | |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 311 | const ParamType* ParamType(const std::string& name) const { |
| 312 | for (const auto& param : parameters) { |
| 313 | if (param.name == name) { |
| 314 | return ¶m; |
| 315 | } |
| 316 | } |
| 317 | return nullptr; |
| 318 | } |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 319 | }; |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 320 | |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 321 | static const std::vector<Schema>& AllSchemas(); |
| 322 | |
| 323 | AidlAnnotation(const AidlLocation& location, const Schema& schema, |
Jooyung Han | 442cacf | 2021-09-13 17:44:56 +0900 | [diff] [blame] | 324 | std::map<std::string, std::shared_ptr<AidlConstantValue>> parameters, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 325 | const Comments& comments); |
Steven Moreland | 0cea4aa | 2020-04-20 21:06:02 -0700 | [diff] [blame] | 326 | |
| 327 | const Schema& schema_; |
Andrei Onea | 9445fc6 | 2019-06-27 18:11:59 +0100 | [diff] [blame] | 328 | std::map<std::string, std::shared_ptr<AidlConstantValue>> parameters_; |
Jiyong Park | 68bc77a | 2018-07-19 19:00:45 +0900 | [diff] [blame] | 329 | }; |
| 330 | |
Steven Moreland | 3be7577 | 2018-08-20 13:27:43 -0700 | [diff] [blame] | 331 | static inline bool operator<(const AidlAnnotation& lhs, const AidlAnnotation& rhs) { |
| 332 | return lhs.GetName() < rhs.GetName(); |
| 333 | } |
| 334 | static inline bool operator==(const AidlAnnotation& lhs, const AidlAnnotation& rhs) { |
| 335 | return lhs.GetName() == rhs.GetName(); |
| 336 | } |
Jiyong Park | 3656c3c | 2018-08-01 20:02:01 +0900 | [diff] [blame] | 337 | |
Jooyung Han | 5c7e77c | 2021-01-20 16:00:29 +0900 | [diff] [blame] | 338 | class AidlAnnotatable : public AidlCommentable { |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 339 | public: |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 340 | AidlAnnotatable(const AidlLocation& location, const Comments& comments); |
Steven Moreland | 3f658cf | 2018-08-20 13:40:54 -0700 | [diff] [blame] | 341 | |
Casey Dahlin | e792293 | 2016-02-29 17:23:01 -0800 | [diff] [blame] | 342 | virtual ~AidlAnnotatable() = default; |
| 343 | |
Steven Moreland | a7560e8 | 2021-10-08 16:24:39 -0700 | [diff] [blame] | 344 | void Annotate(vector<std::unique_ptr<AidlAnnotation>>&& annotations) { |
Artur Satayev | 91fe871 | 2019-07-29 13:06:01 +0100 | [diff] [blame] | 345 | for (auto& annotation : annotations) { |
| 346 | annotations_.emplace_back(std::move(annotation)); |
| 347 | } |
| 348 | } |
Jiyong Park | 68bc77a | 2018-07-19 19:00:45 +0900 | [diff] [blame] | 349 | bool IsNullable() const; |
Jooyung Han | 01720ed | 2021-08-13 07:46:07 +0900 | [diff] [blame] | 350 | bool IsHeapNullable() const; |
Jiyong Park | 68bc77a | 2018-07-19 19:00:45 +0900 | [diff] [blame] | 351 | bool IsUtf8InCpp() const; |
Steven Moreland | a7764e5 | 2020-10-27 17:29:29 +0000 | [diff] [blame] | 352 | bool IsSensitiveData() const; |
Steven Moreland | a57d0a6 | 2019-07-30 09:41:14 -0700 | [diff] [blame] | 353 | bool IsVintfStability() const; |
Jeongik Cha | d0a1027 | 2020-08-06 16:33:36 +0900 | [diff] [blame] | 354 | bool IsJavaOnlyImmutable() const; |
Devin Moore | c7e47a3 | 2020-08-07 10:55:25 -0700 | [diff] [blame] | 355 | bool IsFixedSize() const; |
Jeongik Cha | 88f95a8 | 2020-01-15 13:02:16 +0900 | [diff] [blame] | 356 | bool IsStableApiParcelable(Options::Language lang) const; |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 357 | bool JavaDerive(const std::string& method) const; |
Hao Ke | 2a46d06 | 2021-11-11 19:40:56 +0000 | [diff] [blame] | 358 | bool IsJavaDefault() const; |
Devin Moore | 14ca7d9 | 2022-02-02 00:00:35 +0000 | [diff] [blame] | 359 | bool IsJavaDelegator() const; |
Jiyong Park | 27fd7fd | 2020-08-27 16:25:09 +0900 | [diff] [blame] | 360 | std::string GetDescriptor() const; |
Andrei Onea | 9445fc6 | 2019-06-27 18:11:59 +0100 | [diff] [blame] | 361 | |
| 362 | const AidlAnnotation* UnsupportedAppUsage() const; |
Andrei Homescu | e61feb5 | 2020-08-18 15:44:24 -0700 | [diff] [blame] | 363 | const AidlAnnotation* RustDerive() const; |
Jooyung Han | 672557b | 2020-12-24 05:18:00 +0900 | [diff] [blame] | 364 | const AidlAnnotation* BackingType() const; |
Jooyung Han | f8dbbcc | 2020-12-26 03:05:55 +0900 | [diff] [blame] | 365 | std::vector<std::string> SuppressWarnings() const; |
Thiébaud Weksteen | 65281c4 | 2021-12-15 10:07:10 +1100 | [diff] [blame] | 366 | std::unique_ptr<android::aidl::perm::Expression> EnforceExpression() const; |
Thiébaud Weksteen | e79243a | 2021-11-02 14:36:25 +1100 | [diff] [blame] | 367 | bool IsPermissionManual() const; |
| 368 | bool IsPermissionNone() const; |
Makoto Onuki | 23edf92 | 2022-01-27 16:29:55 -0800 | [diff] [blame] | 369 | bool IsPropagateAllowBlocking() const; |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 370 | |
| 371 | // ToString is for dumping AIDL. |
| 372 | // Returns string representation of annotations. |
| 373 | // e.g) "@JavaDerive(toString=true) @RustDerive(Clone=true, Copy=true)" |
Jiyong Park | 68bc77a | 2018-07-19 19:00:45 +0900 | [diff] [blame] | 374 | std::string ToString() const; |
Casey Dahlin | e792293 | 2016-02-29 17:23:01 -0800 | [diff] [blame] | 375 | |
Steven Moreland | a7560e8 | 2021-10-08 16:24:39 -0700 | [diff] [blame] | 376 | const vector<std::unique_ptr<AidlAnnotation>>& GetAnnotations() const { return annotations_; } |
Jooyung Han | 888c5bc | 2020-12-22 17:28:47 +0900 | [diff] [blame] | 377 | bool CheckValid(const AidlTypenames&) const; |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 378 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
| 379 | for (const auto& annot : GetAnnotations()) { |
Steven Moreland | a7560e8 | 2021-10-08 16:24:39 -0700 | [diff] [blame] | 380 | traverse(*annot); |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 381 | } |
| 382 | } |
Jiyong Park | 3656c3c | 2018-08-01 20:02:01 +0900 | [diff] [blame] | 383 | |
Casey Dahlin | e792293 | 2016-02-29 17:23:01 -0800 | [diff] [blame] | 384 | private: |
Steven Moreland | a7560e8 | 2021-10-08 16:24:39 -0700 | [diff] [blame] | 385 | vector<std::unique_ptr<AidlAnnotation>> annotations_; |
Casey Dahlin | e792293 | 2016-02-29 17:23:01 -0800 | [diff] [blame] | 386 | }; |
| 387 | |
Jooyung Han | 9fafb8d | 2021-11-30 13:19:33 +0900 | [diff] [blame] | 388 | // Represents `[]` |
| 389 | struct DynamicArray {}; |
| 390 | // Represents `[N][M]..` |
| 391 | struct FixedSizeArray { |
| 392 | FixedSizeArray(std::unique_ptr<AidlConstantValue> dim) { dimensions.push_back(std::move(dim)); } |
| 393 | std::vector<std::unique_ptr<AidlConstantValue>> dimensions; |
| 394 | }; |
| 395 | // Represents `[]` or `[N]` part of type specifier |
| 396 | using ArrayType = std::variant<DynamicArray, FixedSizeArray>; |
| 397 | |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 398 | // AidlTypeSpecifier represents a reference to either a built-in type, |
| 399 | // a defined type, or a variant (e.g., array of generic) of a type. |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 400 | class AidlTypeSpecifier final : public AidlAnnotatable, |
| 401 | public AidlParameterizable<unique_ptr<AidlTypeSpecifier>> { |
Casey Dahlin | e792293 | 2016-02-29 17:23:01 -0800 | [diff] [blame] | 402 | public: |
Jooyung Han | 9fafb8d | 2021-11-30 13:19:33 +0900 | [diff] [blame] | 403 | AidlTypeSpecifier(const AidlLocation& location, const string& unresolved_name, |
| 404 | std::optional<ArrayType> array, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 405 | vector<unique_ptr<AidlTypeSpecifier>>* type_params, const Comments& comments); |
Jiyong Park | d59a10d | 2018-07-18 11:12:55 +0900 | [diff] [blame] | 406 | virtual ~AidlTypeSpecifier() = default; |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 407 | |
Jooyung Han | 0cc9963 | 2021-11-30 17:19:05 +0900 | [diff] [blame] | 408 | // View of this type which has one-less dimension(s). |
| 409 | // e.g.) T[] => T, T[N][M] => T[M] |
Steven Moreland | 0cac866 | 2021-10-08 16:43:29 -0700 | [diff] [blame] | 410 | void ViewAsArrayBase(std::function<void(const AidlTypeSpecifier&)> func) const; |
Jooyung Han | ca4f319 | 2021-12-15 11:28:06 +0900 | [diff] [blame] | 411 | // ViewAsArrayBase passes "mutated" type to its callback. |
| 412 | bool IsMutated() const { return mutated_; } |
Steven Moreland | 3f658cf | 2018-08-20 13:40:54 -0700 | [diff] [blame] | 413 | |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 414 | // Returns the full-qualified name of the base type. |
| 415 | // int -> int |
| 416 | // int[] -> int |
| 417 | // List<String> -> List |
| 418 | // IFoo -> foo.bar.IFoo (if IFoo is in package foo.bar) |
| 419 | const string& GetName() const { |
| 420 | if (IsResolved()) { |
| 421 | return fully_qualified_name_; |
| 422 | } else { |
| 423 | return GetUnresolvedName(); |
| 424 | } |
| 425 | } |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 426 | |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 427 | // ToString is for dumping AIDL. |
| 428 | // Returns string representation of this type specifier including annotations. |
| 429 | // This is "annotations type_name type_params? array_marker?". |
| 430 | // e.g) "@utf8InCpp String[]"; |
| 431 | std::string ToString() const; |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 432 | |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 433 | // Signature is for comparing AIDL types. |
| 434 | // Returns string representation of this type specifier. |
| 435 | // This is "type_name type_params? array_marker?". |
| 436 | // e.g.) "String[]" (even if it is annotated with @utf8InCpp) |
Jiyong Park | 02da742 | 2018-07-16 16:00:26 +0900 | [diff] [blame] | 437 | std::string Signature() const; |
| 438 | |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 439 | const string& GetUnresolvedName() const { return unresolved_name_; } |
| 440 | |
Jeongik Cha | 1a7ab64 | 2019-07-29 17:31:02 +0900 | [diff] [blame] | 441 | const std::vector<std::string> GetSplitName() const { return split_name_; } |
| 442 | |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 443 | bool IsResolved() const { return fully_qualified_name_ != ""; } |
| 444 | |
Jooyung Han | 9fafb8d | 2021-11-30 13:19:33 +0900 | [diff] [blame] | 445 | bool IsArray() const { return array_.has_value(); } |
Jooyung Han | 729630b | 2021-12-01 17:32:54 +0900 | [diff] [blame] | 446 | bool IsDynamicArray() const { |
| 447 | return array_.has_value() && std::get_if<DynamicArray>(&*array_) != nullptr; |
| 448 | } |
Jooyung Han | 9fafb8d | 2021-11-30 13:19:33 +0900 | [diff] [blame] | 449 | bool IsFixedSizeArray() const { |
| 450 | return array_.has_value() && std::get_if<FixedSizeArray>(&*array_) != nullptr; |
Steven Moreland | 6c07b83 | 2020-10-29 23:39:53 +0000 | [diff] [blame] | 451 | } |
Jooyung Han | ca4f319 | 2021-12-15 11:28:06 +0900 | [diff] [blame] | 452 | std::vector<int32_t> GetFixedSizeArrayDimensions() const; |
Steven Moreland | 6c07b83 | 2020-10-29 23:39:53 +0000 | [diff] [blame] | 453 | |
Jooyung Han | 9fafb8d | 2021-11-30 13:19:33 +0900 | [diff] [blame] | 454 | const ArrayType& GetArray() const { |
| 455 | AIDL_FATAL_IF(!array_.has_value(), this) << "GetArray() for non-array type"; |
| 456 | return array_.value(); |
| 457 | } |
| 458 | |
| 459 | // Accept transitions from |
| 460 | // T to T[] |
| 461 | // or T to T[N] |
| 462 | // or T[N] to T[N][M] |
| 463 | __attribute__((warn_unused_result)) bool MakeArray(ArrayType array_type); |
| 464 | |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 465 | // Resolve the base type name to a fully-qualified name. Return false if the |
| 466 | // resolution fails. |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 467 | bool Resolve(const AidlTypenames& typenames, const AidlScope* scope); |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 468 | |
Jooyung Han | 888c5bc | 2020-12-22 17:28:47 +0900 | [diff] [blame] | 469 | bool CheckValid(const AidlTypenames& typenames) const; |
Jooyung Han | b4997aa | 2021-10-16 03:26:12 +0900 | [diff] [blame] | 470 | bool LanguageSpecificCheckValid(Options::Language lang) const; |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 471 | const AidlNode& AsAidlNode() const override { return *this; } |
Jiyong Park | 1d2df7d | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 472 | |
Jooyung Han | e9bb9de | 2020-11-01 22:16:57 +0900 | [diff] [blame] | 473 | const AidlDefinedType* GetDefinedType() const; |
Jooyung Han | 9fafb8d | 2021-11-30 13:19:33 +0900 | [diff] [blame] | 474 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override; |
Jooyung Han | 865da49 | 2021-01-03 11:32:47 +0900 | [diff] [blame] | 475 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jooyung Han | e9bb9de | 2020-11-01 22:16:57 +0900 | [diff] [blame] | 476 | |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 477 | private: |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 478 | const string unresolved_name_; |
| 479 | string fully_qualified_name_; |
Jooyung Han | 9fafb8d | 2021-11-30 13:19:33 +0900 | [diff] [blame] | 480 | mutable std::optional<ArrayType> array_; |
Jooyung Han | ca4f319 | 2021-12-15 11:28:06 +0900 | [diff] [blame] | 481 | mutable bool mutated_ = false; // ViewAsArrayBase() sets this as true to distinguish mutated one |
| 482 | // from the original type |
Jeongik Cha | 1a7ab64 | 2019-07-29 17:31:02 +0900 | [diff] [blame] | 483 | vector<string> split_name_; |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 484 | const AidlDefinedType* defined_type_ = nullptr; // set when Resolve() for defined types |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 485 | }; |
| 486 | |
Steven Moreland | 860b194 | 2018-08-16 14:59:28 -0700 | [diff] [blame] | 487 | // Returns the universal value unaltered. |
Jooyung Han | aeb0167 | 2021-11-30 17:29:22 +0900 | [diff] [blame] | 488 | std::string AidlConstantValueDecorator( |
| 489 | const AidlTypeSpecifier& type, |
| 490 | const std::variant<std::string, std::vector<std::string>>& raw_value); |
Steven Moreland | 860b194 | 2018-08-16 14:59:28 -0700 | [diff] [blame] | 491 | |
Jooyung Han | 2aedb11 | 2021-09-29 09:37:59 +0900 | [diff] [blame] | 492 | class AidlMember : public AidlAnnotatable { |
Jooyung Han | 8aeef8c | 2021-01-11 12:16:19 +0900 | [diff] [blame] | 493 | public: |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 494 | AidlMember(const AidlLocation& location, const Comments& comments); |
Jooyung Han | 3f347ca | 2020-12-01 12:41:50 +0900 | [diff] [blame] | 495 | virtual ~AidlMember() = default; |
| 496 | |
| 497 | // non-copyable, non-movable |
| 498 | AidlMember(const AidlMember&) = delete; |
| 499 | AidlMember(AidlMember&&) = delete; |
| 500 | AidlMember& operator=(const AidlMember&) = delete; |
| 501 | AidlMember& operator=(AidlMember&&) = delete; |
Jooyung Han | 3f347ca | 2020-12-01 12:41:50 +0900 | [diff] [blame] | 502 | }; |
| 503 | |
Steven Moreland | 541788d | 2020-05-21 22:05:52 +0000 | [diff] [blame] | 504 | // TODO: This class is used for method arguments and also parcelable fields, |
| 505 | // and it should be split up since default values don't apply to method |
| 506 | // arguments |
Jooyung Han | 3f347ca | 2020-12-01 12:41:50 +0900 | [diff] [blame] | 507 | class AidlVariableDeclaration : public AidlMember { |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 508 | public: |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 509 | AidlVariableDeclaration(const AidlLocation& location, AidlTypeSpecifier* type, |
| 510 | const std::string& name); |
| 511 | AidlVariableDeclaration(const AidlLocation& location, AidlTypeSpecifier* type, |
| 512 | const std::string& name, AidlConstantValue* default_value); |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 513 | virtual ~AidlVariableDeclaration() = default; |
| 514 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 515 | // non-copyable, non-movable |
| 516 | AidlVariableDeclaration(const AidlVariableDeclaration&) = delete; |
| 517 | AidlVariableDeclaration(AidlVariableDeclaration&&) = delete; |
| 518 | AidlVariableDeclaration& operator=(const AidlVariableDeclaration&) = delete; |
| 519 | AidlVariableDeclaration& operator=(AidlVariableDeclaration&&) = delete; |
| 520 | |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 521 | std::string GetName() const { return name_; } |
Jooyung Han | acae85d | 2020-10-28 16:39:09 +0900 | [diff] [blame] | 522 | std::string GetCapitalizedName() const; |
Jiyong Park | d59a10d | 2018-07-18 11:12:55 +0900 | [diff] [blame] | 523 | const AidlTypeSpecifier& GetType() const { return *type_; } |
Steven Moreland | 541788d | 2020-05-21 22:05:52 +0000 | [diff] [blame] | 524 | // if this was constructed explicitly with a default value |
| 525 | bool IsDefaultUserSpecified() const { return default_user_specified_; } |
| 526 | // will return the default value this is constructed with or a default value |
| 527 | // if one is available |
Steven Moreland | 9ea10e3 | 2018-07-19 15:26:09 -0700 | [diff] [blame] | 528 | const AidlConstantValue* GetDefaultValue() const { return default_value_.get(); } |
Jooyung Han | 53fb424 | 2020-12-17 16:03:49 +0900 | [diff] [blame] | 529 | bool HasUsefulDefaultValue() const; |
Steven Moreland | 9ea10e3 | 2018-07-19 15:26:09 -0700 | [diff] [blame] | 530 | |
Jiyong Park | d59a10d | 2018-07-18 11:12:55 +0900 | [diff] [blame] | 531 | AidlTypeSpecifier* GetMutableType() { return type_.get(); } |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 532 | |
Jeongik Cha | db0f59e | 2018-11-01 18:11:21 +0900 | [diff] [blame] | 533 | bool CheckValid(const AidlTypenames& typenames) const; |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 534 | |
| 535 | // ToString is for dumping AIDL. |
| 536 | // Returns string representation of this variable decl including default value. |
| 537 | // This is "annotations type name default_value?". |
| 538 | // e.g) "@utf8InCpp String[] names = {"hello"}" |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 539 | std::string ToString() const; |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 540 | |
| 541 | // Signature is for comparing AIDL types. |
| 542 | // Returns string representation of this variable decl. |
| 543 | // This is "type name". |
| 544 | // e.g) "String[] name" (even if it is annotated with @utf8InCpp and has a default value.) |
Jiyong Park | 02da742 | 2018-07-16 16:00:26 +0900 | [diff] [blame] | 545 | std::string Signature() const; |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 546 | |
Steven Moreland | 860b194 | 2018-08-16 14:59:28 -0700 | [diff] [blame] | 547 | std::string ValueString(const ConstantValueDecorator& decorator) const; |
Steven Moreland | 2529432 | 2018-08-07 18:13:55 -0700 | [diff] [blame] | 548 | |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 549 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override; |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 550 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 551 | |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 552 | private: |
Jiyong Park | d59a10d | 2018-07-18 11:12:55 +0900 | [diff] [blame] | 553 | std::unique_ptr<AidlTypeSpecifier> type_; |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 554 | std::string name_; |
Steven Moreland | 541788d | 2020-05-21 22:05:52 +0000 | [diff] [blame] | 555 | bool default_user_specified_; |
Steven Moreland | 9ea10e3 | 2018-07-19 15:26:09 -0700 | [diff] [blame] | 556 | std::unique_ptr<AidlConstantValue> default_value_; |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 557 | }; |
| 558 | |
| 559 | class AidlArgument : public AidlVariableDeclaration { |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 560 | public: |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 561 | enum Direction { IN_DIR = 1, OUT_DIR = 2, INOUT_DIR = 3 }; |
| 562 | |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 563 | AidlArgument(const AidlLocation& location, AidlArgument::Direction direction, |
| 564 | AidlTypeSpecifier* type, const std::string& name); |
| 565 | AidlArgument(const AidlLocation& location, AidlTypeSpecifier* type, const std::string& name); |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 566 | virtual ~AidlArgument() = default; |
| 567 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 568 | // non-copyable, non-movable |
| 569 | AidlArgument(const AidlArgument&) = delete; |
| 570 | AidlArgument(AidlArgument&&) = delete; |
| 571 | AidlArgument& operator=(const AidlArgument&) = delete; |
| 572 | AidlArgument& operator=(AidlArgument&&) = delete; |
| 573 | |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 574 | Direction GetDirection() const { return direction_; } |
Christopher Wiley | ad33927 | 2015-10-05 19:11:58 -0700 | [diff] [blame] | 575 | bool IsOut() const { return direction_ & OUT_DIR; } |
| 576 | bool IsIn() const { return direction_ & IN_DIR; } |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 577 | bool DirectionWasSpecified() const { return direction_specified_; } |
Jiyong Park | 3656c3c | 2018-08-01 20:02:01 +0900 | [diff] [blame] | 578 | string GetDirectionSpecifier() const; |
Jooyung Han | 020d8d1 | 2021-02-26 17:23:02 +0900 | [diff] [blame] | 579 | bool CheckValid(const AidlTypenames& typenames) const; |
Christopher Wiley | ad33927 | 2015-10-05 19:11:58 -0700 | [diff] [blame] | 580 | |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 581 | // ToString is for dumping AIDL. |
| 582 | // Returns string representation of this argument including direction |
| 583 | // This is "direction annotations type name". |
| 584 | // e.g) "in @utf8InCpp String[] names" |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 585 | std::string ToString() const; |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 586 | |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 587 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 588 | |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 589 | private: |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 590 | Direction direction_; |
| 591 | bool direction_specified_; |
Casey Dahlin | a834dd4 | 2015-09-23 11:52:15 -0700 | [diff] [blame] | 592 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 593 | |
Jooyung Han | 020d8d1 | 2021-02-26 17:23:02 +0900 | [diff] [blame] | 594 | struct ArgumentAspect { |
| 595 | std::string name; |
| 596 | std::set<AidlArgument::Direction> possible_directions; |
| 597 | }; |
| 598 | |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 599 | class AidlUnaryConstExpression; |
| 600 | class AidlBinaryConstExpression; |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 601 | class AidlConstantReference; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 602 | |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 603 | class AidlConstantValue : public AidlNode { |
Casey Dahlin | d40e2fe | 2015-11-24 14:06:52 -0800 | [diff] [blame] | 604 | public: |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 605 | enum class Type { |
| 606 | // WARNING: Don't change this order! The order is used to determine type |
| 607 | // promotion during a binary expression. |
| 608 | BOOLEAN, |
| 609 | INT8, |
| 610 | INT32, |
| 611 | INT64, |
| 612 | ARRAY, |
| 613 | CHARACTER, |
| 614 | STRING, |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 615 | REF, |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 616 | FLOATING, |
| 617 | UNARY, |
| 618 | BINARY, |
| 619 | ERROR, |
| 620 | }; |
| 621 | |
Jooyung Han | 535c5e8 | 2020-12-29 15:16:59 +0900 | [diff] [blame] | 622 | // Returns the evaluated value. T> should match to the actual type. |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 623 | template <typename T> |
Jooyung Han | 535c5e8 | 2020-12-29 15:16:59 +0900 | [diff] [blame] | 624 | T EvaluatedValue() const { |
| 625 | is_evaluated_ || (CheckValid() && evaluate()); |
| 626 | AIDL_FATAL_IF(!is_valid_, this); |
| 627 | |
| 628 | if constexpr (is_vector<T>::value) { |
| 629 | AIDL_FATAL_IF(final_type_ != Type::ARRAY, this); |
| 630 | T result; |
| 631 | for (const auto& v : values_) { |
| 632 | result.push_back(v->EvaluatedValue<typename T::value_type>()); |
| 633 | } |
| 634 | return result; |
| 635 | } else if constexpr (is_one_of<T, float, double>::value) { |
| 636 | AIDL_FATAL_IF(final_type_ != Type::FLOATING, this); |
| 637 | T result; |
| 638 | AIDL_FATAL_IF(!ParseFloating(value_, &result), this); |
| 639 | return result; |
| 640 | } else if constexpr (std::is_same<T, std::string>::value) { |
| 641 | AIDL_FATAL_IF(final_type_ != Type::STRING, this); |
| 642 | return final_string_value_.substr(1, final_string_value_.size() - 2); // unquote " |
| 643 | } else if constexpr (is_one_of<T, int8_t, int32_t, int64_t>::value) { |
| 644 | AIDL_FATAL_IF(final_type_ < Type::INT8 && final_type_ > Type::INT64, this); |
| 645 | return static_cast<T>(final_value_); |
Jooyung Han | dd0d78f | 2021-12-06 10:24:28 +0900 | [diff] [blame] | 646 | } else if constexpr (std::is_same<T, char16_t>::value) { |
Jooyung Han | 535c5e8 | 2020-12-29 15:16:59 +0900 | [diff] [blame] | 647 | AIDL_FATAL_IF(final_type_ != Type::CHARACTER, this); |
| 648 | return final_string_value_.at(1); // unquote ' |
| 649 | } else if constexpr (std::is_same<T, bool>::value) { |
| 650 | static_assert(std::is_same<T, bool>::value, ".."); |
| 651 | AIDL_FATAL_IF(final_type_ != Type::BOOLEAN, this); |
| 652 | return final_value_ != 0; |
| 653 | } else { |
| 654 | static_assert(unsupported_type<T>::value); |
| 655 | } |
| 656 | } |
Casey Dahlin | d40e2fe | 2015-11-24 14:06:52 -0800 | [diff] [blame] | 657 | |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 658 | virtual ~AidlConstantValue() = default; |
Casey Dahlin | d40e2fe | 2015-11-24 14:06:52 -0800 | [diff] [blame] | 659 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 660 | // non-copyable, non-movable |
| 661 | AidlConstantValue(const AidlConstantValue&) = delete; |
| 662 | AidlConstantValue(AidlConstantValue&&) = delete; |
| 663 | AidlConstantValue& operator=(const AidlConstantValue&) = delete; |
| 664 | AidlConstantValue& operator=(AidlConstantValue&&) = delete; |
| 665 | |
Steven Moreland | 541788d | 2020-05-21 22:05:52 +0000 | [diff] [blame] | 666 | // creates default value, when one isn't specified |
| 667 | // nullptr if no default available |
| 668 | static AidlConstantValue* Default(const AidlTypeSpecifier& specifier); |
| 669 | |
Steven Moreland | 2529432 | 2018-08-07 18:13:55 -0700 | [diff] [blame] | 670 | static AidlConstantValue* Boolean(const AidlLocation& location, bool value); |
Jooyung Han | dd0d78f | 2021-12-06 10:24:28 +0900 | [diff] [blame] | 671 | static AidlConstantValue* Character(const AidlLocation& location, const std::string& value); |
Steven Moreland | 2529432 | 2018-08-07 18:13:55 -0700 | [diff] [blame] | 672 | // example: 123, -5498, maybe any size |
Jooyung Han | dd0d78f | 2021-12-06 10:24:28 +0900 | [diff] [blame] | 673 | static AidlConstantValue* Integral(const AidlLocation& location, const std::string& value); |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 674 | static AidlConstantValue* Floating(const AidlLocation& location, const std::string& value); |
Steven Moreland | 860b194 | 2018-08-16 14:59:28 -0700 | [diff] [blame] | 675 | static AidlConstantValue* Array(const AidlLocation& location, |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 676 | std::unique_ptr<vector<unique_ptr<AidlConstantValue>>> values); |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 677 | // example: "\"asdf\"" |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 678 | static AidlConstantValue* String(const AidlLocation& location, const string& value); |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 679 | |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 680 | Type GetType() const { return final_type_; } |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 681 | const std::string& Literal() const { return value_; } |
Steven Moreland | 2529432 | 2018-08-07 18:13:55 -0700 | [diff] [blame] | 682 | |
Devin Moore | 2a45d0a | 2022-01-21 22:58:52 +0000 | [diff] [blame] | 683 | bool Evaluate() const; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 684 | virtual bool CheckValid() const; |
Steven Moreland | 860b194 | 2018-08-16 14:59:28 -0700 | [diff] [blame] | 685 | |
| 686 | // Raw value of type (currently valid in C++ and Java). Empty string on error. |
Steven Moreland | 4bcb05c | 2019-11-27 18:57:47 -0800 | [diff] [blame] | 687 | string ValueString(const AidlTypeSpecifier& type, const ConstantValueDecorator& decorator) const; |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 688 | |
| 689 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const { |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 690 | if (type_ == Type::ARRAY) { |
| 691 | for (const auto& v : values_) { |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 692 | traverse(*v); |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 693 | } |
| 694 | } |
| 695 | } |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 696 | void DispatchVisit(AidlVisitor& visitor) const override { visitor.Visit(*this); } |
Casey Dahlin | d40e2fe | 2015-11-24 14:06:52 -0800 | [diff] [blame] | 697 | |
| 698 | private: |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 699 | AidlConstantValue(const AidlLocation& location, Type parsed_type, int64_t parsed_value, |
| 700 | const string& checked_value); |
| 701 | AidlConstantValue(const AidlLocation& location, Type type, const string& checked_value); |
Steven Moreland | 860b194 | 2018-08-16 14:59:28 -0700 | [diff] [blame] | 702 | AidlConstantValue(const AidlLocation& location, Type type, |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 703 | std::unique_ptr<vector<unique_ptr<AidlConstantValue>>> values, |
| 704 | const std::string& value); |
Steven Moreland | 2529432 | 2018-08-07 18:13:55 -0700 | [diff] [blame] | 705 | static string ToString(Type type); |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 706 | static bool ParseIntegral(const string& value, int64_t* parsed_value, Type* parsed_type); |
| 707 | static bool IsHex(const string& value); |
Steven Moreland | 4bcb05c | 2019-11-27 18:57:47 -0800 | [diff] [blame] | 708 | |
Jooyung Han | 74675c2 | 2020-12-15 08:39:57 +0900 | [diff] [blame] | 709 | virtual bool evaluate() const; |
Casey Dahlin | d40e2fe | 2015-11-24 14:06:52 -0800 | [diff] [blame] | 710 | |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 711 | const Type type_ = Type::ERROR; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 712 | const vector<unique_ptr<AidlConstantValue>> values_; // if type_ == ARRAY |
| 713 | const string value_; // otherwise |
| 714 | |
| 715 | // State for tracking evaluation of expressions |
Steven Moreland | 4bcb05c | 2019-11-27 18:57:47 -0800 | [diff] [blame] | 716 | mutable bool is_valid_ = false; // cache of CheckValid, but may be marked false in evaluate |
| 717 | mutable bool is_evaluated_ = false; // whether evaluate has been called |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 718 | mutable Type final_type_; |
| 719 | mutable int64_t final_value_; |
| 720 | mutable string final_string_value_ = ""; |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 721 | |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 722 | friend AidlUnaryConstExpression; |
| 723 | friend AidlBinaryConstExpression; |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 724 | friend AidlConstantReference; |
| 725 | }; |
| 726 | |
| 727 | // Represents "<type>.<field>" which resolves to a constant which is one of |
| 728 | // - constant declartion |
| 729 | // - enumerator |
| 730 | // When a <type> is missing, <field> is of the enclosing type. |
| 731 | class AidlConstantReference : public AidlConstantValue { |
| 732 | public: |
Jooyung Han | d0c8af0 | 2021-01-06 18:08:01 +0900 | [diff] [blame] | 733 | AidlConstantReference(const AidlLocation& location, const std::string& value); |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 734 | |
| 735 | const std::unique_ptr<AidlTypeSpecifier>& GetRefType() const { return ref_type_; } |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 736 | const std::string& GetFieldName() const { return field_name_; } |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 737 | |
| 738 | bool CheckValid() const override; |
Jooyung Han | 289a1bc | 2021-05-15 15:04:05 +0900 | [diff] [blame] | 739 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
| 740 | if (ref_type_) { |
| 741 | traverse(*ref_type_); |
| 742 | } |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 743 | } |
| 744 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jooyung Han | 9d3cbe2 | 2020-12-28 03:02:08 +0900 | [diff] [blame] | 745 | const AidlConstantValue* Resolve(const AidlDefinedType* scope) const; |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 746 | |
| 747 | private: |
Jooyung Han | 74675c2 | 2020-12-15 08:39:57 +0900 | [diff] [blame] | 748 | bool evaluate() const override; |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 749 | |
| 750 | std::unique_ptr<AidlTypeSpecifier> ref_type_; |
| 751 | std::string field_name_; |
Jooyung Han | 9d3cbe2 | 2020-12-28 03:02:08 +0900 | [diff] [blame] | 752 | mutable const AidlConstantValue* resolved_ = nullptr; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 753 | }; |
| 754 | |
| 755 | class AidlUnaryConstExpression : public AidlConstantValue { |
| 756 | public: |
| 757 | AidlUnaryConstExpression(const AidlLocation& location, const string& op, |
| 758 | std::unique_ptr<AidlConstantValue> rval); |
| 759 | |
| 760 | static bool IsCompatibleType(Type type, const string& op); |
| 761 | bool CheckValid() const override; |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 762 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
| 763 | traverse(*unary_); |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 764 | } |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 765 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 766 | |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 767 | private: |
Jooyung Han | 74675c2 | 2020-12-15 08:39:57 +0900 | [diff] [blame] | 768 | bool evaluate() const override; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 769 | |
| 770 | std::unique_ptr<AidlConstantValue> unary_; |
| 771 | const string op_; |
| 772 | }; |
| 773 | |
| 774 | class AidlBinaryConstExpression : public AidlConstantValue { |
| 775 | public: |
| 776 | AidlBinaryConstExpression(const AidlLocation& location, std::unique_ptr<AidlConstantValue> lval, |
| 777 | const string& op, std::unique_ptr<AidlConstantValue> rval); |
| 778 | |
| 779 | bool CheckValid() const override; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 780 | |
| 781 | static bool AreCompatibleTypes(Type t1, Type t2); |
| 782 | // Returns the promoted kind for both operands |
| 783 | static Type UsualArithmeticConversion(Type left, Type right); |
| 784 | // Returns the promoted integral type where INT32 is the smallest type |
| 785 | static Type IntegralPromotion(Type in); |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 786 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
| 787 | traverse(*left_val_); |
| 788 | traverse(*right_val_); |
Jooyung Han | 690f584 | 2020-12-04 13:02:04 +0900 | [diff] [blame] | 789 | } |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 790 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 791 | |
| 792 | private: |
Jooyung Han | 74675c2 | 2020-12-15 08:39:57 +0900 | [diff] [blame] | 793 | bool evaluate() const override; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 794 | |
| 795 | std::unique_ptr<AidlConstantValue> left_val_; |
| 796 | std::unique_ptr<AidlConstantValue> right_val_; |
| 797 | const string op_; |
Christopher Wiley | d6bdd8d | 2016-05-03 11:23:13 -0700 | [diff] [blame] | 798 | }; |
| 799 | |
Andrei Onea | 9445fc6 | 2019-06-27 18:11:59 +0100 | [diff] [blame] | 800 | struct AidlAnnotationParameter { |
| 801 | std::string name; |
| 802 | std::unique_ptr<AidlConstantValue> value; |
| 803 | }; |
| 804 | |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 805 | class AidlConstantDeclaration : public AidlMember { |
Christopher Wiley | d6bdd8d | 2016-05-03 11:23:13 -0700 | [diff] [blame] | 806 | public: |
Steven Moreland | 46e9da8 | 2018-07-27 15:45:29 -0700 | [diff] [blame] | 807 | AidlConstantDeclaration(const AidlLocation& location, AidlTypeSpecifier* specifier, |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 808 | const string& name, AidlConstantValue* value); |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 809 | virtual ~AidlConstantDeclaration() = default; |
Christopher Wiley | d6bdd8d | 2016-05-03 11:23:13 -0700 | [diff] [blame] | 810 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 811 | // non-copyable, non-movable |
| 812 | AidlConstantDeclaration(const AidlConstantDeclaration&) = delete; |
| 813 | AidlConstantDeclaration(AidlConstantDeclaration&&) = delete; |
| 814 | AidlConstantDeclaration& operator=(const AidlConstantDeclaration&) = delete; |
| 815 | AidlConstantDeclaration& operator=(AidlConstantDeclaration&&) = delete; |
| 816 | |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 817 | const AidlTypeSpecifier& GetType() const { return *type_; } |
Steven Moreland | 4d12f9a | 2018-10-31 14:30:55 -0700 | [diff] [blame] | 818 | AidlTypeSpecifier* GetMutableType() { return type_.get(); } |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 819 | const string& GetName() const { return name_; } |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 820 | const AidlConstantValue& GetValue() const { return *value_; } |
Jeongik Cha | db0f59e | 2018-11-01 18:11:21 +0900 | [diff] [blame] | 821 | bool CheckValid(const AidlTypenames& typenames) const; |
Christopher Wiley | d6bdd8d | 2016-05-03 11:23:13 -0700 | [diff] [blame] | 822 | |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 823 | // ToString is for dumping AIDL. |
| 824 | // Returns string representation of this const decl including a const value. |
| 825 | // This is "`const` annotations type name value". |
| 826 | // e.g) "const @utf8InCpp String[] names = { "hello" }" |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 827 | string ToString() const; |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 828 | |
| 829 | // Signature is for comparing types. |
| 830 | // Returns string representation of this const decl. |
| 831 | // This is "direction annotations type name". |
| 832 | // e.g) "String[] names" |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 833 | string Signature() const; |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 834 | |
Steven Moreland | 860b194 | 2018-08-16 14:59:28 -0700 | [diff] [blame] | 835 | string ValueString(const ConstantValueDecorator& decorator) const { |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 836 | return value_->ValueString(GetType(), decorator); |
Steven Moreland | 860b194 | 2018-08-16 14:59:28 -0700 | [diff] [blame] | 837 | } |
Steven Moreland | 2529432 | 2018-08-07 18:13:55 -0700 | [diff] [blame] | 838 | |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 839 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
Jooyung Han | 865da49 | 2021-01-03 11:32:47 +0900 | [diff] [blame] | 840 | traverse(GetType()); |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 841 | traverse(GetValue()); |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 842 | } |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 843 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 844 | |
Christopher Wiley | d6bdd8d | 2016-05-03 11:23:13 -0700 | [diff] [blame] | 845 | private: |
Steven Moreland | 693640b | 2018-07-19 13:46:27 -0700 | [diff] [blame] | 846 | const unique_ptr<AidlTypeSpecifier> type_; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 847 | const string name_; |
| 848 | unique_ptr<AidlConstantValue> value_; |
Casey Dahlin | d40e2fe | 2015-11-24 14:06:52 -0800 | [diff] [blame] | 849 | }; |
| 850 | |
| 851 | class AidlMethod : public AidlMember { |
Casey Dahlin | 5c69deb | 2015-10-01 14:44:12 -0700 | [diff] [blame] | 852 | public: |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 853 | AidlMethod(const AidlLocation& location, bool oneway, AidlTypeSpecifier* type, const string& name, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 854 | vector<unique_ptr<AidlArgument>>* args, const Comments& comments); |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 855 | AidlMethod(const AidlLocation& location, bool oneway, AidlTypeSpecifier* type, const string& name, |
Jooyung Han | ae01675 | 2022-02-26 21:33:43 +0900 | [diff] [blame] | 856 | vector<unique_ptr<AidlArgument>>* args, const Comments& comments, int id); |
Casey Dahlin | 5c69deb | 2015-10-01 14:44:12 -0700 | [diff] [blame] | 857 | virtual ~AidlMethod() = default; |
| 858 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 859 | // non-copyable, non-movable |
| 860 | AidlMethod(const AidlMethod&) = delete; |
| 861 | AidlMethod(AidlMethod&&) = delete; |
| 862 | AidlMethod& operator=(const AidlMethod&) = delete; |
| 863 | AidlMethod& operator=(AidlMethod&&) = delete; |
| 864 | |
Thiébaud Weksteen | ff6dafa | 2021-09-21 11:53:40 +0200 | [diff] [blame] | 865 | bool CheckValid(const AidlTypenames&) const; |
Jiyong Park | d59a10d | 2018-07-18 11:12:55 +0900 | [diff] [blame] | 866 | const AidlTypeSpecifier& GetType() const { return *type_; } |
| 867 | AidlTypeSpecifier* GetMutableType() { return type_.get(); } |
Steven Moreland | acd5347 | 2018-12-14 10:17:26 -0800 | [diff] [blame] | 868 | |
Steven Moreland | 8c70ba9 | 2018-12-17 10:20:31 -0800 | [diff] [blame] | 869 | // set if this method is part of an interface that is marked oneway |
| 870 | void ApplyInterfaceOneway(bool oneway) { oneway_ = oneway_ || oneway; } |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 871 | bool IsOneway() const { return oneway_; } |
Steven Moreland | acd5347 | 2018-12-14 10:17:26 -0800 | [diff] [blame] | 872 | |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 873 | const std::string& GetName() const { return name_; } |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 874 | bool HasId() const { return has_id_; } |
Jiyong Park | ed65bf4 | 2018-08-28 15:43:27 +0900 | [diff] [blame] | 875 | int GetId() const { return id_; } |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 876 | void SetId(unsigned id) { id_ = id; } |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 877 | |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 878 | const std::vector<std::unique_ptr<AidlArgument>>& GetArguments() const { |
Christopher Wiley | ad33927 | 2015-10-05 19:11:58 -0700 | [diff] [blame] | 879 | return arguments_; |
| 880 | } |
| 881 | // An inout parameter will appear in both GetInArguments() |
| 882 | // and GetOutArguments(). AidlMethod retains ownership of the argument |
| 883 | // pointers returned in this way. |
| 884 | const std::vector<const AidlArgument*>& GetInArguments() const { |
| 885 | return in_arguments_; |
| 886 | } |
| 887 | const std::vector<const AidlArgument*>& GetOutArguments() const { |
| 888 | return out_arguments_; |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 889 | } |
Casey Dahlin | 5c69deb | 2015-10-01 14:44:12 -0700 | [diff] [blame] | 890 | |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 891 | // ToString is for dumping AIDL. |
| 892 | // Returns string representation of this method including everything. |
| 893 | // This is "ret_type name ( arg_list ) = id". |
| 894 | // e.g) "boolean foo(int, @Nullable String) = 1" |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 895 | std::string ToString() const; |
| 896 | |
Jooyung Han | 965e31d | 2020-11-27 12:30:16 +0900 | [diff] [blame] | 897 | // Signature is for comparing AIDL types. |
| 898 | // Returns string representation of this method's name & type. |
| 899 | // e.g) "foo(int, String)" |
| 900 | std::string Signature() const; |
| 901 | |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 902 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
Jooyung Han | 865da49 | 2021-01-03 11:32:47 +0900 | [diff] [blame] | 903 | traverse(GetType()); |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 904 | for (const auto& a : GetArguments()) { |
| 905 | traverse(*a); |
| 906 | } |
| 907 | } |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 908 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 909 | |
Casey Dahlin | 5c69deb | 2015-10-01 14:44:12 -0700 | [diff] [blame] | 910 | private: |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 911 | bool oneway_; |
Jiyong Park | d59a10d | 2018-07-18 11:12:55 +0900 | [diff] [blame] | 912 | std::unique_ptr<AidlTypeSpecifier> type_; |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 913 | std::string name_; |
Christopher Wiley | ad33927 | 2015-10-05 19:11:58 -0700 | [diff] [blame] | 914 | const std::vector<std::unique_ptr<AidlArgument>> arguments_; |
| 915 | std::vector<const AidlArgument*> in_arguments_; |
| 916 | std::vector<const AidlArgument*> out_arguments_; |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 917 | bool has_id_; |
| 918 | int id_; |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 919 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 920 | |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 921 | // AidlDefinedType represents either an interface, parcelable, or enum that is |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 922 | // defined in the source file. |
Jooyung Han | 2aedb11 | 2021-09-29 09:37:59 +0900 | [diff] [blame] | 923 | class AidlDefinedType : public AidlMember, public AidlScope { |
Steven Moreland | 787b043 | 2018-07-03 09:00:58 -0700 | [diff] [blame] | 924 | public: |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 925 | AidlDefinedType(const AidlLocation& location, const std::string& name, const Comments& comments, |
| 926 | const std::string& package, std::vector<std::unique_ptr<AidlMember>>* members); |
Steven Moreland | 787b043 | 2018-07-03 09:00:58 -0700 | [diff] [blame] | 927 | virtual ~AidlDefinedType() = default; |
| 928 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 929 | // non-copyable, non-movable |
| 930 | AidlDefinedType(const AidlDefinedType&) = delete; |
| 931 | AidlDefinedType(AidlDefinedType&&) = delete; |
| 932 | AidlDefinedType& operator=(const AidlDefinedType&) = delete; |
| 933 | AidlDefinedType& operator=(AidlDefinedType&&) = delete; |
| 934 | |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 935 | const std::string& GetName() const { return name_; }; |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 936 | |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 937 | std::string ResolveName(const std::string& name) const override; |
| 938 | |
Steven Moreland | 787b043 | 2018-07-03 09:00:58 -0700 | [diff] [blame] | 939 | /* dot joined package, example: "android.package.foo" */ |
Jiyong Park | 1813218 | 2020-06-08 20:24:40 +0900 | [diff] [blame] | 940 | std::string GetPackage() const { return package_; } |
Steven Moreland | 787b043 | 2018-07-03 09:00:58 -0700 | [diff] [blame] | 941 | /* dot joined package and name, example: "android.package.foo.IBar" */ |
| 942 | std::string GetCanonicalName() const; |
Jooyung Han | 93f48f0 | 2021-06-05 00:11:16 +0900 | [diff] [blame] | 943 | std::vector<std::string> GetSplitPackage() const { |
| 944 | if (package_.empty()) return std::vector<std::string>(); |
| 945 | return android::base::Split(package_, "."); |
| 946 | } |
Jooyung Han | 3578498 | 2021-06-29 06:26:12 +0900 | [diff] [blame] | 947 | const AidlDocument& GetDocument() const; |
Steven Moreland | 787b043 | 2018-07-03 09:00:58 -0700 | [diff] [blame] | 948 | |
Steven Moreland | ed83a28 | 2018-07-17 13:27:29 -0700 | [diff] [blame] | 949 | virtual std::string GetPreprocessDeclarationName() const = 0; |
Steven Moreland | c258abc | 2018-07-10 14:03:38 -0700 | [diff] [blame] | 950 | |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 951 | virtual const AidlStructuredParcelable* AsStructuredParcelable() const { return nullptr; } |
Steven Moreland | c258abc | 2018-07-10 14:03:38 -0700 | [diff] [blame] | 952 | virtual const AidlParcelable* AsParcelable() const { return nullptr; } |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 953 | virtual const AidlEnumDeclaration* AsEnumDeclaration() const { return nullptr; } |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 954 | virtual const AidlUnionDecl* AsUnionDeclaration() const { return nullptr; } |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 955 | virtual const AidlInterface* AsInterface() const { return nullptr; } |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 956 | virtual const AidlParameterizable<std::string>* AsParameterizable() const { return nullptr; } |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 957 | virtual bool CheckValid(const AidlTypenames& typenames) const; |
Jooyung Han | b4997aa | 2021-10-16 03:26:12 +0900 | [diff] [blame] | 958 | bool LanguageSpecificCheckValid(Options::Language lang) const; |
Steven Moreland | c258abc | 2018-07-10 14:03:38 -0700 | [diff] [blame] | 959 | AidlStructuredParcelable* AsStructuredParcelable() { |
| 960 | return const_cast<AidlStructuredParcelable*>( |
| 961 | const_cast<const AidlDefinedType*>(this)->AsStructuredParcelable()); |
| 962 | } |
| 963 | AidlParcelable* AsParcelable() { |
| 964 | return const_cast<AidlParcelable*>(const_cast<const AidlDefinedType*>(this)->AsParcelable()); |
| 965 | } |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 966 | AidlEnumDeclaration* AsEnumDeclaration() { |
| 967 | return const_cast<AidlEnumDeclaration*>( |
| 968 | const_cast<const AidlDefinedType*>(this)->AsEnumDeclaration()); |
| 969 | } |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 970 | AidlUnionDecl* AsUnionDeclaration() { |
| 971 | return const_cast<AidlUnionDecl*>( |
| 972 | const_cast<const AidlDefinedType*>(this)->AsUnionDeclaration()); |
| 973 | } |
Steven Moreland | c258abc | 2018-07-10 14:03:38 -0700 | [diff] [blame] | 974 | AidlInterface* AsInterface() { |
| 975 | return const_cast<AidlInterface*>(const_cast<const AidlDefinedType*>(this)->AsInterface()); |
| 976 | } |
| 977 | |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 978 | AidlParameterizable<std::string>* AsParameterizable() { |
| 979 | return const_cast<AidlParameterizable<std::string>*>( |
| 980 | const_cast<const AidlDefinedType*>(this)->AsParameterizable()); |
| 981 | } |
| 982 | |
Steven Moreland | 6cee348 | 2018-07-18 14:39:58 -0700 | [diff] [blame] | 983 | const AidlParcelable* AsUnstructuredParcelable() const { |
| 984 | if (this->AsStructuredParcelable() != nullptr) return nullptr; |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 985 | if (this->AsUnionDeclaration() != nullptr) return nullptr; |
Steven Moreland | 6cee348 | 2018-07-18 14:39:58 -0700 | [diff] [blame] | 986 | return this->AsParcelable(); |
| 987 | } |
| 988 | AidlParcelable* AsUnstructuredParcelable() { |
| 989 | return const_cast<AidlParcelable*>( |
| 990 | const_cast<const AidlDefinedType*>(this)->AsUnstructuredParcelable()); |
| 991 | } |
Jooyung Han | 2aedb11 | 2021-09-29 09:37:59 +0900 | [diff] [blame] | 992 | const AidlDefinedType* GetParentType() const; |
Jooyung Han | f8c3963 | 2021-10-05 09:56:29 +0900 | [diff] [blame] | 993 | const AidlDefinedType* GetRootType() const; |
Jooyung Han | 2aedb11 | 2021-09-29 09:37:59 +0900 | [diff] [blame] | 994 | const std::vector<std::unique_ptr<AidlDefinedType>>& GetNestedTypes() const { return types_; } |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 995 | const std::vector<std::unique_ptr<AidlVariableDeclaration>>& GetFields() const { |
| 996 | return variables_; |
| 997 | } |
| 998 | const std::vector<std::unique_ptr<AidlConstantDeclaration>>& GetConstantDeclarations() const { |
| 999 | return constants_; |
| 1000 | } |
| 1001 | const std::vector<std::unique_ptr<AidlMethod>>& GetMethods() const { return methods_; } |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1002 | const std::vector<const AidlMember*>& GetMembers() const { return members_; } |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 1003 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
| 1004 | AidlAnnotatable::TraverseChildren(traverse); |
| 1005 | for (const auto c : GetMembers()) { |
| 1006 | traverse(*c); |
| 1007 | } |
| 1008 | } |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1009 | |
Jooyung Han | feb76db | 2022-03-17 00:43:17 +0000 | [diff] [blame] | 1010 | // Modifiers |
| 1011 | void AddMethod(std::unique_ptr<AidlMethod> method) { |
| 1012 | members_.push_back(method.get()); |
| 1013 | methods_.push_back(std::move(method)); |
| 1014 | } |
| 1015 | void AddType(std::unique_ptr<AidlDefinedType> type) { |
| 1016 | type->SetEnclosingScope(this); |
| 1017 | members_.push_back(type.get()); |
| 1018 | types_.push_back(std::move(type)); |
| 1019 | } |
| 1020 | |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1021 | protected: |
| 1022 | // utility for subclasses with getter names |
| 1023 | bool CheckValidForGetterNames() const; |
| 1024 | |
Steven Moreland | 787b043 | 2018-07-03 09:00:58 -0700 | [diff] [blame] | 1025 | private: |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1026 | bool CheckValidWithMembers(const AidlTypenames& typenames) const; |
| 1027 | |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 1028 | std::string name_; |
Jooyung Han | 93f48f0 | 2021-06-05 00:11:16 +0900 | [diff] [blame] | 1029 | std::string package_; |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1030 | std::vector<std::unique_ptr<AidlVariableDeclaration>> variables_; |
| 1031 | std::vector<std::unique_ptr<AidlConstantDeclaration>> constants_; |
| 1032 | std::vector<std::unique_ptr<AidlMethod>> methods_; |
Jooyung Han | 2aedb11 | 2021-09-29 09:37:59 +0900 | [diff] [blame] | 1033 | std::vector<std::unique_ptr<AidlDefinedType>> types_; |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1034 | std::vector<const AidlMember*> members_; // keep members in order of appearance. |
Steven Moreland | 787b043 | 2018-07-03 09:00:58 -0700 | [diff] [blame] | 1035 | }; |
| 1036 | |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 1037 | class AidlParcelable : public AidlDefinedType, public AidlParameterizable<std::string> { |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 1038 | public: |
Jiyong Park | 1813218 | 2020-06-08 20:24:40 +0900 | [diff] [blame] | 1039 | AidlParcelable(const AidlLocation& location, const std::string& name, const std::string& package, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 1040 | const Comments& comments, const std::string& cpp_header = "", |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1041 | std::vector<std::string>* type_params = nullptr, |
| 1042 | std::vector<std::unique_ptr<AidlMember>>* members = nullptr); |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 1043 | virtual ~AidlParcelable() = default; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 1044 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 1045 | // non-copyable, non-movable |
| 1046 | AidlParcelable(const AidlParcelable&) = delete; |
| 1047 | AidlParcelable(AidlParcelable&&) = delete; |
| 1048 | AidlParcelable& operator=(const AidlParcelable&) = delete; |
| 1049 | AidlParcelable& operator=(AidlParcelable&&) = delete; |
| 1050 | |
Christopher Wiley | 8aa4d9f | 2015-11-16 19:10:45 -0800 | [diff] [blame] | 1051 | std::string GetCppHeader() const { return cpp_header_; } |
Christopher Wiley | 8aa4d9f | 2015-11-16 19:10:45 -0800 | [diff] [blame] | 1052 | |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 1053 | bool CheckValid(const AidlTypenames& typenames) const override; |
Steven Moreland | c258abc | 2018-07-10 14:03:38 -0700 | [diff] [blame] | 1054 | const AidlParcelable* AsParcelable() const override { return this; } |
Jeongik Cha | df76dc7 | 2019-11-28 00:08:47 +0900 | [diff] [blame] | 1055 | const AidlParameterizable<std::string>* AsParameterizable() const override { return this; } |
| 1056 | const AidlNode& AsAidlNode() const override { return *this; } |
Steven Moreland | ed83a28 | 2018-07-17 13:27:29 -0700 | [diff] [blame] | 1057 | std::string GetPreprocessDeclarationName() const override { return "parcelable"; } |
Steven Moreland | c258abc | 2018-07-10 14:03:38 -0700 | [diff] [blame] | 1058 | |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 1059 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1060 | |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 1061 | private: |
Christopher Wiley | 8aa4d9f | 2015-11-16 19:10:45 -0800 | [diff] [blame] | 1062 | std::string cpp_header_; |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 1063 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 1064 | |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1065 | class AidlStructuredParcelable : public AidlParcelable { |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 1066 | public: |
Jiyong Park | 1813218 | 2020-06-08 20:24:40 +0900 | [diff] [blame] | 1067 | AidlStructuredParcelable(const AidlLocation& location, const std::string& name, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 1068 | const std::string& package, const Comments& comments, |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1069 | std::vector<std::string>* type_params, |
| 1070 | std::vector<std::unique_ptr<AidlMember>>* members); |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 1071 | virtual ~AidlStructuredParcelable() = default; |
| 1072 | |
| 1073 | // non-copyable, non-movable |
| 1074 | AidlStructuredParcelable(const AidlStructuredParcelable&) = delete; |
| 1075 | AidlStructuredParcelable(AidlStructuredParcelable&&) = delete; |
| 1076 | AidlStructuredParcelable& operator=(const AidlStructuredParcelable&) = delete; |
| 1077 | AidlStructuredParcelable& operator=(AidlStructuredParcelable&&) = delete; |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 1078 | |
Steven Moreland | c258abc | 2018-07-10 14:03:38 -0700 | [diff] [blame] | 1079 | const AidlStructuredParcelable* AsStructuredParcelable() const override { return this; } |
Steven Moreland | ed83a28 | 2018-07-17 13:27:29 -0700 | [diff] [blame] | 1080 | std::string GetPreprocessDeclarationName() const override { return "structured_parcelable"; } |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 1081 | |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 1082 | bool CheckValid(const AidlTypenames& typenames) const override; |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 1083 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 1084 | }; |
| 1085 | |
Jooyung Han | 5c7e77c | 2021-01-20 16:00:29 +0900 | [diff] [blame] | 1086 | class AidlEnumerator : public AidlCommentable { |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1087 | public: |
Daniel Norman | 2e4112d | 2019-10-03 10:22:35 -0700 | [diff] [blame] | 1088 | AidlEnumerator(const AidlLocation& location, const std::string& name, AidlConstantValue* value, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 1089 | const Comments& comments); |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1090 | virtual ~AidlEnumerator() = default; |
| 1091 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 1092 | // non-copyable, non-movable |
| 1093 | AidlEnumerator(const AidlEnumerator&) = delete; |
| 1094 | AidlEnumerator(AidlEnumerator&&) = delete; |
| 1095 | AidlEnumerator& operator=(const AidlEnumerator&) = delete; |
| 1096 | AidlEnumerator& operator=(AidlEnumerator&&) = delete; |
| 1097 | |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1098 | const std::string& GetName() const { return name_; } |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 1099 | AidlConstantValue* GetValue() const { return value_.get(); } |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1100 | bool CheckValid(const AidlTypeSpecifier& enum_backing_type) const; |
| 1101 | |
| 1102 | string ValueString(const AidlTypeSpecifier& backing_type, |
| 1103 | const ConstantValueDecorator& decorator) const; |
| 1104 | |
Daniel Norman | b28684e | 2019-10-17 15:31:39 -0700 | [diff] [blame] | 1105 | void SetValue(std::unique_ptr<AidlConstantValue> value) { value_ = std::move(value); } |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 1106 | bool IsValueUserSpecified() const { return value_user_specified_; } |
Daniel Norman | b28684e | 2019-10-17 15:31:39 -0700 | [diff] [blame] | 1107 | |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 1108 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
| 1109 | traverse(*value_); |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1110 | } |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 1111 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1112 | |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1113 | private: |
| 1114 | const std::string name_; |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 1115 | unique_ptr<AidlConstantValue> value_; |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 1116 | const bool value_user_specified_; |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1117 | }; |
| 1118 | |
| 1119 | class AidlEnumDeclaration : public AidlDefinedType { |
| 1120 | public: |
Will McVicker | d7d18df | 2019-09-12 13:40:50 -0700 | [diff] [blame] | 1121 | AidlEnumDeclaration(const AidlLocation& location, const string& name, |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1122 | std::vector<std::unique_ptr<AidlEnumerator>>* enumerators, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 1123 | const std::string& package, const Comments& comments); |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1124 | virtual ~AidlEnumDeclaration() = default; |
| 1125 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 1126 | // non-copyable, non-movable |
| 1127 | AidlEnumDeclaration(const AidlEnumDeclaration&) = delete; |
| 1128 | AidlEnumDeclaration(AidlEnumDeclaration&&) = delete; |
| 1129 | AidlEnumDeclaration& operator=(const AidlEnumDeclaration&) = delete; |
| 1130 | AidlEnumDeclaration& operator=(AidlEnumDeclaration&&) = delete; |
| 1131 | |
Jooyung Han | 672557b | 2020-12-24 05:18:00 +0900 | [diff] [blame] | 1132 | bool Autofill(const AidlTypenames&); |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1133 | const AidlTypeSpecifier& GetBackingType() const { return *backing_type_; } |
| 1134 | const std::vector<std::unique_ptr<AidlEnumerator>>& GetEnumerators() const { |
| 1135 | return enumerators_; |
| 1136 | } |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 1137 | bool CheckValid(const AidlTypenames& typenames) const override; |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1138 | std::string GetPreprocessDeclarationName() const override { return "enum"; } |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1139 | |
| 1140 | const AidlEnumDeclaration* AsEnumDeclaration() const override { return this; } |
| 1141 | |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 1142 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
| 1143 | AidlDefinedType::TraverseChildren(traverse); |
Jooyung Han | ca84b03 | 2021-09-30 02:15:59 +0900 | [diff] [blame] | 1144 | if (backing_type_) { |
| 1145 | traverse(*backing_type_); |
| 1146 | } |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1147 | for (const auto& c : GetEnumerators()) { |
| 1148 | traverse(*c); |
| 1149 | } |
| 1150 | } |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 1151 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1152 | |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1153 | private: |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 1154 | |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1155 | const std::string name_; |
| 1156 | const std::vector<std::unique_ptr<AidlEnumerator>> enumerators_; |
Jooyung Han | 672557b | 2020-12-24 05:18:00 +0900 | [diff] [blame] | 1157 | std::unique_ptr<AidlTypeSpecifier> backing_type_; |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 1158 | }; |
| 1159 | |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1160 | class AidlUnionDecl : public AidlParcelable { |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 1161 | public: |
| 1162 | AidlUnionDecl(const AidlLocation& location, const std::string& name, const std::string& package, |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 1163 | const Comments& comments, std::vector<std::string>* type_params, |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1164 | std::vector<std::unique_ptr<AidlMember>>* members); |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 1165 | virtual ~AidlUnionDecl() = default; |
| 1166 | |
| 1167 | // non-copyable, non-movable |
| 1168 | AidlUnionDecl(const AidlUnionDecl&) = delete; |
| 1169 | AidlUnionDecl(AidlUnionDecl&&) = delete; |
| 1170 | AidlUnionDecl& operator=(const AidlUnionDecl&) = delete; |
| 1171 | AidlUnionDecl& operator=(AidlUnionDecl&&) = delete; |
| 1172 | |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 1173 | |
| 1174 | const AidlNode& AsAidlNode() const override { return *this; } |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 1175 | bool CheckValid(const AidlTypenames& typenames) const override; |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 1176 | std::string GetPreprocessDeclarationName() const override { return "union"; } |
| 1177 | |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 1178 | const AidlUnionDecl* AsUnionDeclaration() const override { return this; } |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 1179 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 1180 | }; |
| 1181 | |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 1182 | class AidlInterface final : public AidlDefinedType { |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 1183 | public: |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 1184 | AidlInterface(const AidlLocation& location, const std::string& name, const Comments& comments, |
Jooyung Han | db4d8a6 | 2021-06-22 10:09:42 +0900 | [diff] [blame] | 1185 | bool oneway, const std::string& package, |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 1186 | std::vector<std::unique_ptr<AidlMember>>* members); |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 1187 | virtual ~AidlInterface() = default; |
| 1188 | |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 1189 | // non-copyable, non-movable |
| 1190 | AidlInterface(const AidlInterface&) = delete; |
| 1191 | AidlInterface(AidlInterface&&) = delete; |
| 1192 | AidlInterface& operator=(const AidlInterface&) = delete; |
| 1193 | AidlInterface& operator=(AidlInterface&&) = delete; |
| 1194 | |
Steven Moreland | c258abc | 2018-07-10 14:03:38 -0700 | [diff] [blame] | 1195 | const AidlInterface* AsInterface() const override { return this; } |
Steven Moreland | ed83a28 | 2018-07-17 13:27:29 -0700 | [diff] [blame] | 1196 | std::string GetPreprocessDeclarationName() const override { return "interface"; } |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 1197 | |
Jooyung Han | 808a2a0 | 2020-12-28 16:46:54 +0900 | [diff] [blame] | 1198 | bool CheckValid(const AidlTypenames& typenames) const override; |
Thiébaud Weksteen | e79243a | 2021-11-02 14:36:25 +1100 | [diff] [blame] | 1199 | bool CheckValidPermissionAnnotations(const AidlMethod& m) const; |
Jiyong Park | 27fd7fd | 2020-08-27 16:25:09 +0900 | [diff] [blame] | 1200 | std::string GetDescriptor() const; |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 1201 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 1202 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 1203 | |
Jooyung Han | cdf89ec | 2021-10-29 14:08:30 +0900 | [diff] [blame] | 1204 | inline std::string SimpleName(const std::string& qualified_name) { |
| 1205 | return qualified_name.substr(qualified_name.rfind('.') + 1); |
| 1206 | } |
Casey Dahlin | e250749 | 2015-09-14 17:11:20 -0700 | [diff] [blame] | 1207 | |
Jiyong Park | 6251551 | 2020-06-08 15:57:11 +0900 | [diff] [blame] | 1208 | // AidlDocument models an AIDL file |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 1209 | class AidlDocument : public AidlCommentable, public AidlScope { |
Jiyong Park | 6251551 | 2020-06-08 15:57:11 +0900 | [diff] [blame] | 1210 | public: |
Jooyung Han | 8451a20 | 2021-01-16 03:07:06 +0900 | [diff] [blame] | 1211 | AidlDocument(const AidlLocation& location, const Comments& comments, |
Jooyung Han | f08c15f | 2022-01-28 14:57:13 +0900 | [diff] [blame] | 1212 | std::vector<std::string> imports, |
Jooyung Han | 3578498 | 2021-06-29 06:26:12 +0900 | [diff] [blame] | 1213 | std::vector<std::unique_ptr<AidlDefinedType>> defined_types, bool is_preprocessed); |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 1214 | ~AidlDocument() = default; |
| 1215 | |
| 1216 | // non-copyable, non-movable |
Jiyong Park | 8e79b7f | 2020-07-20 20:52:38 +0900 | [diff] [blame] | 1217 | AidlDocument(const AidlDocument&) = delete; |
| 1218 | AidlDocument(AidlDocument&&) = delete; |
| 1219 | AidlDocument& operator=(const AidlDocument&) = delete; |
| 1220 | AidlDocument& operator=(AidlDocument&&) = delete; |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 1221 | |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 1222 | std::string ResolveName(const std::string& name) const override; |
Jooyung Han | f08c15f | 2022-01-28 14:57:13 +0900 | [diff] [blame] | 1223 | const std::vector<std::string>& Imports() const { return imports_; } |
Jiyong Park | d800fef | 2020-07-22 18:09:43 +0900 | [diff] [blame] | 1224 | const std::vector<std::unique_ptr<AidlDefinedType>>& DefinedTypes() const { |
| 1225 | return defined_types_; |
| 1226 | } |
Jooyung Han | 3578498 | 2021-06-29 06:26:12 +0900 | [diff] [blame] | 1227 | bool IsPreprocessed() const { return is_preprocessed_; } |
Jiyong Park | 6251551 | 2020-06-08 15:57:11 +0900 | [diff] [blame] | 1228 | |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 1229 | void TraverseChildren(std::function<void(const AidlNode&)> traverse) const override { |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1230 | for (const auto& t : DefinedTypes()) { |
| 1231 | traverse(*t); |
| 1232 | } |
| 1233 | } |
Jiyong Park | 4585445 | 2020-12-31 10:42:28 +0900 | [diff] [blame] | 1234 | void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1235 | |
Jiyong Park | 6251551 | 2020-06-08 15:57:11 +0900 | [diff] [blame] | 1236 | private: |
Jooyung Han | f08c15f | 2022-01-28 14:57:13 +0900 | [diff] [blame] | 1237 | const std::vector<std::string> imports_; |
Jiyong Park | 8e79b7f | 2020-07-20 20:52:38 +0900 | [diff] [blame] | 1238 | const std::vector<std::unique_ptr<AidlDefinedType>> defined_types_; |
Jooyung Han | 3578498 | 2021-06-29 06:26:12 +0900 | [diff] [blame] | 1239 | bool is_preprocessed_; |
Jiyong Park | 6251551 | 2020-06-08 15:57:11 +0900 | [diff] [blame] | 1240 | }; |
Jooyung Han | b3c77ed | 2020-12-26 02:02:45 +0900 | [diff] [blame] | 1241 | |
| 1242 | template <typename T> |
| 1243 | std::optional<T> AidlAnnotation::ParamValue(const std::string& param_name) const { |
| 1244 | auto it = parameters_.find(param_name); |
| 1245 | if (it == parameters_.end()) { |
| 1246 | return std::nullopt; |
| 1247 | } |
Jooyung Han | 535c5e8 | 2020-12-29 15:16:59 +0900 | [diff] [blame] | 1248 | return it->second->EvaluatedValue<T>(); |
Jiyong Park | 512ed85 | 2020-12-30 15:07:23 +0900 | [diff] [blame] | 1249 | } |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 1250 | |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 1251 | // Utilities to make a visitor to visit AST tree in top-down order |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 1252 | // Given: foo |
| 1253 | // / \ |
| 1254 | // bar baz |
| 1255 | // VisitTopDown(v, foo) makes v visit foo -> bar -> baz. |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 1256 | inline void VisitTopDown(std::function<void(const AidlNode&)> v, const AidlNode& node) { |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 1257 | std::function<void(const AidlNode&)> top_down = [&](const AidlNode& n) { |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 1258 | v(n); |
Jooyung Han | c5688f7 | 2021-01-05 15:41:48 +0900 | [diff] [blame] | 1259 | n.TraverseChildren(top_down); |
| 1260 | }; |
| 1261 | top_down(node); |
Jooyung Han | 289a1bc | 2021-05-15 15:04:05 +0900 | [diff] [blame] | 1262 | } |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 1263 | inline void VisitTopDown(AidlVisitor& v, const AidlNode& node) { |
| 1264 | VisitTopDown([&](const AidlNode& n) { n.DispatchVisit(v); }, node); |
| 1265 | } |
Jooyung Han | 289a1bc | 2021-05-15 15:04:05 +0900 | [diff] [blame] | 1266 | |
| 1267 | // Utility to make a visitor to visit AST tree in bottom-up order |
| 1268 | // Given: foo |
| 1269 | // / \ |
| 1270 | // bar baz |
| 1271 | // VisitBottomUp(v, foo) makes v visit bar -> baz -> foo. |
| 1272 | inline void VisitBottomUp(AidlVisitor& v, const AidlNode& node) { |
| 1273 | std::function<void(const AidlNode&)> bottom_up = [&](const AidlNode& n) { |
| 1274 | n.TraverseChildren(bottom_up); |
| 1275 | n.DispatchVisit(v); |
| 1276 | }; |
| 1277 | bottom_up(node); |
Thiébaud Weksteen | 5a4db21 | 2021-09-02 17:09:34 +0200 | [diff] [blame] | 1278 | } |
Jooyung Han | baa7106 | 2021-09-29 09:06:03 +0900 | [diff] [blame] | 1279 | |
| 1280 | template <typename T> |
| 1281 | const T* AidlCast(const AidlNode& node) { |
| 1282 | struct CastVisitor : AidlVisitor { |
| 1283 | const T* cast = nullptr; |
| 1284 | void Visit(const T& t) override { cast = &t; } |
| 1285 | } visitor; |
| 1286 | node.DispatchVisit(visitor); |
| 1287 | return visitor.cast; |
| 1288 | } |
| 1289 | |
| 1290 | template <> |
| 1291 | const AidlDefinedType* AidlCast<AidlDefinedType>(const AidlNode& node); |
| 1292 | |
| 1293 | template <typename T> |
| 1294 | T* AidlCast(AidlNode& node) { |
| 1295 | return const_cast<T*>(AidlCast<T>(const_cast<const AidlNode&>(node))); |
| 1296 | } |
Jooyung Han | 8e9ae87 | 2021-10-13 02:52:25 +0900 | [diff] [blame] | 1297 | |
| 1298 | template <typename AidlNodeType> |
| 1299 | vector<const AidlNodeType*> Collect(const AidlNode& root) { |
| 1300 | vector<const AidlNodeType*> result; |
| 1301 | std::function<void(const AidlNode&)> top_down = [&](const AidlNode& n) { |
| 1302 | if (auto cast = AidlCast<AidlNodeType>(n); cast) { |
| 1303 | result.push_back(cast); |
| 1304 | } |
| 1305 | n.TraverseChildren(top_down); |
| 1306 | }; |
| 1307 | top_down(root); |
| 1308 | return result; |
| 1309 | } |
| 1310 | |
| 1311 | template <typename VisitFn> |
| 1312 | bool TopologicalVisit(const vector<unique_ptr<AidlDefinedType>>& nested_types, VisitFn visit) { |
| 1313 | // 1. Maps deeply nested types to one of nested_types |
| 1314 | map<const AidlDefinedType*, const AidlDefinedType*> roots; |
| 1315 | for (const auto& nested : nested_types) { |
| 1316 | for (const auto& t : Collect<AidlDefinedType>(*nested)) { |
| 1317 | roots[t] = nested.get(); |
| 1318 | } |
| 1319 | } |
| 1320 | // 2. Collect sibling types referenced within each nested type. |
| 1321 | map<const AidlDefinedType*, vector<const AidlDefinedType*>> required_types; |
| 1322 | for (const auto& nested : nested_types) { |
| 1323 | for (const auto& t : Collect<AidlTypeSpecifier>(*nested)) { |
| 1324 | if (auto defined_type = t->GetDefinedType(); defined_type) { |
| 1325 | auto sibling = roots[defined_type]; |
| 1326 | if (sibling && sibling != nested.get()) { |
| 1327 | required_types[nested.get()].push_back(sibling); |
| 1328 | } |
| 1329 | } |
| 1330 | } |
| 1331 | }; |
| 1332 | // 3. Run DFS |
| 1333 | enum { NOT_STARTED = 0, STARTED = 1, FINISHED = 2 }; |
| 1334 | map<const AidlDefinedType*, int> visited; |
| 1335 | std::function<bool(const AidlDefinedType&)> dfs = [&](const AidlDefinedType& type) { |
| 1336 | if (visited[&type] == FINISHED) { |
| 1337 | return true; |
| 1338 | } else if (visited[&type] == STARTED) { |
| 1339 | return false; |
| 1340 | } else { |
| 1341 | visited[&type] = STARTED; |
| 1342 | // Visit every required dep first |
| 1343 | for (const auto& dep_type : required_types[&type]) { |
| 1344 | if (!dfs(*dep_type)) { |
| 1345 | return false; |
| 1346 | } |
| 1347 | } |
| 1348 | visited[&type] = FINISHED; |
| 1349 | visit(type); |
| 1350 | return true; |
| 1351 | } |
| 1352 | }; |
| 1353 | |
| 1354 | for (const auto& type : nested_types) { |
| 1355 | if (!dfs(*type)) { |
| 1356 | return false; |
| 1357 | } |
| 1358 | } |
| 1359 | |
| 1360 | return true; |
| 1361 | } |