OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 the V8 project authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #ifndef V8_EXPRESSION_CLASSIFIER_H |
| 6 #define V8_EXPRESSION_CLASSIFIER_H |
| 7 |
| 8 #include "src/v8.h" |
| 9 |
| 10 #include "src/messages.h" |
| 11 #include "src/scanner.h" |
| 12 #include "src/token.h" |
| 13 |
| 14 namespace v8 { |
| 15 namespace internal { |
| 16 |
| 17 |
| 18 class ExpressionClassifier { |
| 19 public: |
| 20 struct Error { |
| 21 Error() |
| 22 : location(Scanner::Location::invalid()), |
| 23 message(MessageTemplate::kNone), |
| 24 arg(nullptr) {} |
| 25 |
| 26 Scanner::Location location; |
| 27 MessageTemplate::Template message; |
| 28 const char* arg; |
| 29 }; |
| 30 |
| 31 enum TargetProduction { |
| 32 ExpressionProduction = 1 << 0, |
| 33 BindingPatternProduction = 1 << 1, |
| 34 AssignmentPatternProduction = 1 << 2, |
| 35 DistinctFormalParametersProduction = 1 << 3, |
| 36 StrictModeFormalParametersProduction = 1 << 4, |
| 37 StrongModeFormalParametersProduction = 1 << 5, |
| 38 ArrowFormalParametersProduction = 1 << 6, |
| 39 |
| 40 PatternProductions = |
| 41 (BindingPatternProduction | AssignmentPatternProduction), |
| 42 FormalParametersProductions = (DistinctFormalParametersProduction | |
| 43 StrictModeFormalParametersProduction | |
| 44 StrongModeFormalParametersProduction), |
| 45 StandardProductions = ExpressionProduction | PatternProductions, |
| 46 AllProductions = (StandardProductions | FormalParametersProductions | |
| 47 ArrowFormalParametersProduction) |
| 48 }; |
| 49 |
| 50 ExpressionClassifier() |
| 51 : invalid_productions_(0), duplicate_finder_(nullptr) {} |
| 52 |
| 53 explicit ExpressionClassifier(DuplicateFinder* duplicate_finder) |
| 54 : invalid_productions_(0), duplicate_finder_(duplicate_finder) {} |
| 55 |
| 56 bool is_valid(unsigned productions) const { |
| 57 return (invalid_productions_ & productions) == 0; |
| 58 } |
| 59 |
| 60 DuplicateFinder* duplicate_finder() const { return duplicate_finder_; } |
| 61 |
| 62 bool is_valid_expression() const { return is_valid(ExpressionProduction); } |
| 63 |
| 64 bool is_valid_binding_pattern() const { |
| 65 return is_valid(BindingPatternProduction); |
| 66 } |
| 67 |
| 68 bool is_valid_assignment_pattern() const { |
| 69 return is_valid(AssignmentPatternProduction); |
| 70 } |
| 71 |
| 72 bool is_valid_arrow_formal_parameters() const { |
| 73 return is_valid(ArrowFormalParametersProduction); |
| 74 } |
| 75 |
| 76 bool is_valid_formal_parameter_list_without_duplicates() const { |
| 77 return is_valid(DistinctFormalParametersProduction); |
| 78 } |
| 79 |
| 80 // Note: callers should also check |
| 81 // is_valid_formal_parameter_list_without_duplicates(). |
| 82 bool is_valid_strict_mode_formal_parameters() const { |
| 83 return is_valid(StrictModeFormalParametersProduction); |
| 84 } |
| 85 |
| 86 // Note: callers should also check is_valid_strict_mode_formal_parameters() |
| 87 // and is_valid_formal_parameter_list_without_duplicates(). |
| 88 bool is_valid_strong_mode_formal_parameters() const { |
| 89 return is_valid(StrongModeFormalParametersProduction); |
| 90 } |
| 91 |
| 92 const Error& expression_error() const { return expression_error_; } |
| 93 |
| 94 const Error& binding_pattern_error() const { return binding_pattern_error_; } |
| 95 |
| 96 const Error& assignment_pattern_error() const { |
| 97 return assignment_pattern_error_; |
| 98 } |
| 99 |
| 100 const Error& arrow_formal_parameters_error() const { |
| 101 return arrow_formal_parameters_error_; |
| 102 } |
| 103 |
| 104 const Error& duplicate_formal_parameter_error() const { |
| 105 return duplicate_formal_parameter_error_; |
| 106 } |
| 107 |
| 108 const Error& strict_mode_formal_parameter_error() const { |
| 109 return strict_mode_formal_parameter_error_; |
| 110 } |
| 111 |
| 112 const Error& strong_mode_formal_parameter_error() const { |
| 113 return strong_mode_formal_parameter_error_; |
| 114 } |
| 115 |
| 116 void RecordExpressionError(const Scanner::Location& loc, |
| 117 MessageTemplate::Template message, |
| 118 const char* arg = nullptr) { |
| 119 if (!is_valid_expression()) return; |
| 120 invalid_productions_ |= ExpressionProduction; |
| 121 expression_error_.location = loc; |
| 122 class ExpressionClassifier { |
| 123 public: |
| 124 struct Error { |
| 125 Error() |
| 126 : location(Scanner::Location::invalid()), |
| 127 message(MessageTemplate::kNone), |
| 128 arg(nullptr) {} |
| 129 |
| 130 Scanner::Location location; |
| 131 MessageTemplate::Template message; |
| 132 const char* arg; |
| 133 |
| 134 bool HasError() const { return location.IsValid(); } |
| 135 }; |
| 136 |
| 137 ExpressionClassifier() : duplicate_finder_(nullptr) {} |
| 138 |
| 139 explicit ExpressionClassifier(DuplicateFinder* duplicate_finder) |
| 140 : duplicate_finder_(duplicate_finder) {} |
| 141 |
| 142 DuplicateFinder* duplicate_finder() const { return duplicate_finder_; } |
| 143 |
| 144 bool is_valid_expression() const { return !expression_error_.HasError(); } |
| 145 |
| 146 bool is_valid_binding_pattern() const { |
| 147 return !binding_pattern_error_.HasError(); |
| 148 } |
| 149 |
| 150 bool is_valid_assignment_pattern() const { |
| 151 return !assignment_pattern_error_.HasError(); |
| 152 } |
| 153 |
| 154 bool is_valid_arrow_formal_parameters() const { |
| 155 return !arrow_formal_parameters_error_.HasError(); |
| 156 } |
| 157 |
| 158 bool is_valid_formal_parameter_list_without_duplicates() const { |
| 159 return !duplicate_formal_parameter_error_.HasError(); |
| 160 } |
| 161 |
| 162 // Note: callers should also check |
| 163 // is_valid_formal_parameter_list_without_duplicates(). |
| 164 bool is_valid_strict_mode_formal_parameters() const { |
| 165 return !strict_mode_formal_parameter_error_.HasError(); |
| 166 } |
| 167 |
| 168 // Note: callers should also check |
| 169 // is_valid_strict_mode_formal_parameters() |
| 170 // and is_valid_formal_parameter_list_without_duplicates(). |
| 171 bool is_valid_strong_mode_formal_parameters() const { |
| 172 return !strong_mode_formal_parameter_error_.HasError(); |
| 173 } |
| 174 |
| 175 const Error& expression_error() const { return expression_error_; } |
| 176 |
| 177 const Error& binding_pattern_error() const { |
| 178 return binding_pattern_error_; |
| 179 } |
| 180 |
| 181 const Error& assignment_pattern_error() const { |
| 182 return assignment_pattern_error_; |
| 183 } |
| 184 |
| 185 const Error& arrow_formal_parameters_error() const { |
| 186 return arrow_formal_parameters_error_; |
| 187 } |
| 188 |
| 189 const Error& duplicate_formal_parameter_error() const { |
| 190 return duplicate_formal_parameter_error_; |
| 191 } |
| 192 |
| 193 const Error& strict_mode_formal_parameter_error() const { |
| 194 return strict_mode_formal_parameter_error_; |
| 195 } |
| 196 |
| 197 const Error& strong_mode_formal_parameter_error() const { |
| 198 return strong_mode_formal_parameter_error_; |
| 199 } |
| 200 |
| 201 void RecordExpressionError(const Scanner::Location& loc, |
| 202 MessageTemplate::Template message, |
| 203 const char* arg = nullptr) { |
| 204 if (!is_valid_expression()) return; |
| 205 expression_error_.location = loc; |
| 206 expression_error_.message = message; |
| 207 expression_error_.arg = arg; |
| 208 } |
| 209 |
| 210 void RecordBindingPatternError(const Scanner::Location& loc, |
| 211 MessageTemplate::Template message, |
| 212 const char* arg = nullptr) { |
| 213 if (!is_valid_binding_pattern()) return; |
| 214 binding_pattern_error_.location = loc; |
| 215 binding_pattern_error_.message = message; |
| 216 binding_pattern_error_.arg = arg; |
| 217 } |
| 218 |
| 219 void RecordAssignmentPatternError(const Scanner::Location& loc, |
| 220 MessageTemplate::Template message, |
| 221 const char* arg = nullptr) { |
| 222 if (!is_valid_assignment_pattern()) return; |
| 223 assignment_pattern_error_.location = loc; |
| 224 assignment_pattern_error_.message = message; |
| 225 assignment_pattern_error_.arg = arg; |
| 226 } |
| 227 |
| 228 void RecordArrowFormalParametersError(const Scanner::Location& loc, |
| 229 MessageTemplate::Template message, |
| 230 const char* arg = nullptr) { |
| 231 if (!is_valid_arrow_formal_parameters()) return; |
| 232 arrow_formal_parameters_error_.location = loc; |
| 233 arrow_formal_parameters_error_.message = message; |
| 234 arrow_formal_parameters_error_.arg = arg; |
| 235 } |
| 236 |
| 237 void RecordDuplicateFormalParameterError(const Scanner::Location& loc) { |
| 238 if (!is_valid_formal_parameter_list_without_duplicates()) return; |
| 239 duplicate_formal_parameter_error_.location = loc; |
| 240 duplicate_formal_parameter_error_.message = |
| 241 MessageTemplate::kStrictParamDupe; |
| 242 duplicate_formal_parameter_error_.arg = nullptr; |
| 243 } |
| 244 |
| 245 // Record a binding that would be invalid in strict mode. Confusingly |
| 246 // this |
| 247 // is not the same as StrictFormalParameterList, which simply forbids |
| 248 // duplicate bindings. |
| 249 void RecordStrictModeFormalParameterError( |
| 250 const Scanner::Location& loc, MessageTemplate::Template message, |
| 251 const char* arg = nullptr) { |
| 252 if (!is_valid_strict_mode_formal_parameters()) return; |
| 253 strict_mode_formal_parameter_error_.location = loc; |
| 254 strict_mode_formal_parameter_error_.message = message; |
| 255 strict_mode_formal_parameter_error_.arg = arg; |
| 256 } |
| 257 |
| 258 void RecordStrongModeFormalParameterError( |
| 259 const Scanner::Location& loc, MessageTemplate::Template message, |
| 260 const char* arg = nullptr) { |
| 261 if (!is_valid_strong_mode_formal_parameters()) return; |
| 262 strong_mode_formal_parameter_error_.location = loc; |
| 263 strong_mode_formal_parameter_error_.message = message; |
| 264 strong_mode_formal_parameter_error_.arg = arg; |
| 265 } |
| 266 |
| 267 enum TargetProduction { |
| 268 ExpressionProduction = 1 << 0, |
| 269 BindingPatternProduction = 1 << 1, |
| 270 AssignmentPatternProduction = 1 << 2, |
| 271 FormalParametersProduction = 1 << 3, |
| 272 ArrowFormalParametersProduction = 1 << 4, |
| 273 StandardProductions = (ExpressionProduction | BindingPatternProduction | |
| 274 AssignmentPatternProduction), |
| 275 PatternProductions = |
| 276 BindingPatternProduction | AssignmentPatternProduction, |
| 277 AllProductions = (StandardProductions | FormalParametersProduction | |
| 278 ArrowFormalParametersProduction), |
| 279 }; |
| 280 |
| 281 void Accumulate(const ExpressionClassifier& inner, |
| 282 unsigned productions = StandardProductions) { |
| 283 if (productions & ExpressionProduction && is_valid_expression()) { |
| 284 expression_error_ = inner.expression_error_; |
| 285 } |
| 286 if (productions & BindingPatternProduction && |
| 287 is_valid_binding_pattern()) { |
| 288 binding_pattern_error_ = inner.binding_pattern_error_; |
| 289 } |
| 290 if (productions & AssignmentPatternProduction && |
| 291 is_valid_assignment_pattern()) { |
| 292 assignment_pattern_error_ = inner.assignment_pattern_error_; |
| 293 } |
| 294 if (productions & FormalParametersProduction) { |
| 295 if (is_valid_formal_parameter_list_without_duplicates()) { |
| 296 duplicate_formal_parameter_error_ = |
| 297 inner.duplicate_formal_parameter_error_; |
| 298 } |
| 299 if (is_valid_strict_mode_formal_parameters()) { |
| 300 strict_mode_formal_parameter_error_ = |
| 301 inner.strict_mode_formal_parameter_error_; |
| 302 } |
| 303 if (is_valid_strong_mode_formal_parameters()) { |
| 304 strong_mode_formal_parameter_error_ = |
| 305 inner.strong_mode_formal_parameter_error_; |
| 306 } |
| 307 } |
| 308 if (productions & ArrowFormalParametersProduction && |
| 309 is_valid_arrow_formal_parameters()) { |
| 310 // The result continues to be a valid arrow formal parameters if the |
| 311 // inner expression is a valid binding pattern. |
| 312 arrow_formal_parameters_error_ = inner.binding_pattern_error_; |
| 313 } |
| 314 } |
| 315 |
| 316 void AccumulateReclassifyingAsPattern(const ExpressionClassifier& inner) { |
| 317 Accumulate(inner, AllProductions & ~PatternProductions); |
| 318 if (!inner.is_valid_expression()) { |
| 319 if (is_valid_binding_pattern()) { |
| 320 binding_pattern_error_ = inner.expression_error(); |
| 321 } |
| 322 if (is_valid_assignment_pattern()) { |
| 323 assignment_pattern_error_ = inner.expression_error(); |
| 324 } |
| 325 } |
| 326 } |
| 327 |
| 328 private: |
| 329 Error expression_error_; |
| 330 Error binding_pattern_error_; |
| 331 Error assignment_pattern_error_; |
| 332 Error arrow_formal_parameters_error_; |
| 333 Error duplicate_formal_parameter_error_; |
| 334 Error strict_mode_formal_parameter_error_; |
| 335 Error strong_mode_formal_parameter_error_; |
| 336 DuplicateFinder* duplicate_finder_; |
| 337 }; |
| 338 expression_error_.message = message; |
| 339 expression_error_.arg = arg; |
| 340 } |
| 341 |
| 342 void RecordBindingPatternError(const Scanner::Location& loc, |
| 343 MessageTemplate::Template message, |
| 344 const char* arg = nullptr) { |
| 345 if (!is_valid_binding_pattern()) return; |
| 346 invalid_productions_ |= BindingPatternProduction; |
| 347 binding_pattern_error_.location = loc; |
| 348 binding_pattern_error_.message = message; |
| 349 binding_pattern_error_.arg = arg; |
| 350 } |
| 351 |
| 352 void RecordAssignmentPatternError(const Scanner::Location& loc, |
| 353 MessageTemplate::Template message, |
| 354 const char* arg = nullptr) { |
| 355 if (!is_valid_assignment_pattern()) return; |
| 356 invalid_productions_ |= AssignmentPatternProduction; |
| 357 assignment_pattern_error_.location = loc; |
| 358 assignment_pattern_error_.message = message; |
| 359 assignment_pattern_error_.arg = arg; |
| 360 } |
| 361 |
| 362 void RecordArrowFormalParametersError(const Scanner::Location& loc, |
| 363 MessageTemplate::Template message, |
| 364 const char* arg = nullptr) { |
| 365 if (!is_valid_arrow_formal_parameters()) return; |
| 366 invalid_productions_ |= ArrowFormalParametersProduction; |
| 367 arrow_formal_parameters_error_.location = loc; |
| 368 arrow_formal_parameters_error_.message = message; |
| 369 arrow_formal_parameters_error_.arg = arg; |
| 370 } |
| 371 |
| 372 void RecordDuplicateFormalParameterError(const Scanner::Location& loc) { |
| 373 if (!is_valid_formal_parameter_list_without_duplicates()) return; |
| 374 invalid_productions_ |= DistinctFormalParametersProduction; |
| 375 duplicate_formal_parameter_error_.location = loc; |
| 376 duplicate_formal_parameter_error_.message = |
| 377 MessageTemplate::kStrictParamDupe; |
| 378 duplicate_formal_parameter_error_.arg = nullptr; |
| 379 } |
| 380 |
| 381 // Record a binding that would be invalid in strict mode. Confusingly this |
| 382 // is not the same as StrictFormalParameterList, which simply forbids |
| 383 // duplicate bindings. |
| 384 void RecordStrictModeFormalParameterError(const Scanner::Location& loc, |
| 385 MessageTemplate::Template message, |
| 386 const char* arg = nullptr) { |
| 387 if (!is_valid_strict_mode_formal_parameters()) return; |
| 388 invalid_productions_ |= StrictModeFormalParametersProduction; |
| 389 strict_mode_formal_parameter_error_.location = loc; |
| 390 strict_mode_formal_parameter_error_.message = message; |
| 391 strict_mode_formal_parameter_error_.arg = arg; |
| 392 } |
| 393 |
| 394 void RecordStrongModeFormalParameterError(const Scanner::Location& loc, |
| 395 MessageTemplate::Template message, |
| 396 const char* arg = nullptr) { |
| 397 if (!is_valid_strong_mode_formal_parameters()) return; |
| 398 invalid_productions_ |= StrongModeFormalParametersProduction; |
| 399 strong_mode_formal_parameter_error_.location = loc; |
| 400 strong_mode_formal_parameter_error_.message = message; |
| 401 strong_mode_formal_parameter_error_.arg = arg; |
| 402 } |
| 403 |
| 404 void Accumulate(const ExpressionClassifier& inner, |
| 405 unsigned productions = StandardProductions) { |
| 406 // Propagate errors from inner, but don't overwrite already recorded |
| 407 // errors. |
| 408 unsigned non_arrow_inner_invalid_productions = |
| 409 inner.invalid_productions_ & ~ArrowFormalParametersProduction; |
| 410 if (non_arrow_inner_invalid_productions == 0) return; |
| 411 unsigned non_arrow_productions = |
| 412 productions & ~ArrowFormalParametersProduction; |
| 413 unsigned errors = |
| 414 non_arrow_productions & non_arrow_inner_invalid_productions; |
| 415 errors &= ~invalid_productions_; |
| 416 if (errors != 0) { |
| 417 invalid_productions_ |= errors; |
| 418 if (errors & ExpressionProduction) |
| 419 expression_error_ = inner.expression_error_; |
| 420 if (errors & BindingPatternProduction) |
| 421 binding_pattern_error_ = inner.binding_pattern_error_; |
| 422 if (errors & AssignmentPatternProduction) |
| 423 assignment_pattern_error_ = inner.assignment_pattern_error_; |
| 424 if (errors & DistinctFormalParametersProduction) |
| 425 duplicate_formal_parameter_error_ = |
| 426 inner.duplicate_formal_parameter_error_; |
| 427 if (errors & StrictModeFormalParametersProduction) |
| 428 strict_mode_formal_parameter_error_ = |
| 429 inner.strict_mode_formal_parameter_error_; |
| 430 if (errors & StrongModeFormalParametersProduction) |
| 431 strong_mode_formal_parameter_error_ = |
| 432 inner.strong_mode_formal_parameter_error_; |
| 433 } |
| 434 |
| 435 // As an exception to the above, the result continues to be a valid arrow |
| 436 // formal parameters if the inner expression is a valid binding pattern. |
| 437 if (productions & ArrowFormalParametersProduction && |
| 438 is_valid_arrow_formal_parameters() && |
| 439 !inner.is_valid_binding_pattern()) { |
| 440 invalid_productions_ |= ArrowFormalParametersProduction; |
| 441 arrow_formal_parameters_error_ = inner.binding_pattern_error_; |
| 442 } |
| 443 } |
| 444 |
| 445 void AccumulateReclassifyingAsPattern(const ExpressionClassifier& inner) { |
| 446 Accumulate(inner, AllProductions & ~PatternProductions); |
| 447 if (!inner.is_valid_expression()) { |
| 448 if (is_valid_binding_pattern()) { |
| 449 binding_pattern_error_ = inner.expression_error(); |
| 450 } |
| 451 if (is_valid_assignment_pattern()) { |
| 452 assignment_pattern_error_ = inner.expression_error(); |
| 453 } |
| 454 } |
| 455 } |
| 456 |
| 457 private: |
| 458 unsigned invalid_productions_; |
| 459 Error expression_error_; |
| 460 Error binding_pattern_error_; |
| 461 Error assignment_pattern_error_; |
| 462 Error arrow_formal_parameters_error_; |
| 463 Error duplicate_formal_parameter_error_; |
| 464 Error strict_mode_formal_parameter_error_; |
| 465 Error strong_mode_formal_parameter_error_; |
| 466 DuplicateFinder* duplicate_finder_; |
| 467 }; |
| 468 } |
| 469 } // v8::internal |
| 470 |
| 471 #endif // V8_EXPRESSION_CLASSIFIER_H |
OLD | NEW |