Base tests and examples
This commit is contained in:
Mark Skelton
@@ -0,0 +1,102 @@
|
||||
================================================
|
||||
template functions vs relational expressions
|
||||
================================================
|
||||
|
||||
T1 a = b < c > d;
|
||||
T2 e = f<T3>(g);
|
||||
int a = std::get<0>(t);
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(binary_expression
|
||||
(binary_expression (identifier) (identifier))
|
||||
(identifier))))
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(call_expression
|
||||
(template_function (identifier) (template_argument_list
|
||||
(type_descriptor (type_identifier))))
|
||||
(argument_list (identifier)))))
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(call_expression
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_function
|
||||
(identifier)
|
||||
(template_argument_list (number_literal))))
|
||||
(argument_list (identifier))))))
|
||||
|
||||
=================================================
|
||||
function declarations vs variable initializations
|
||||
=================================================
|
||||
|
||||
// Function declarations
|
||||
T1 a(T2 *b);
|
||||
T3 c(T4 &d, T5 &&e);
|
||||
|
||||
// Variable declarations with initializers
|
||||
T7 f(g.h);
|
||||
T6 i{j};
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(comment)
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list (parameter_declaration (type_identifier) (pointer_declarator (identifier))))))
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration (type_identifier) (reference_declarator (identifier)))
|
||||
(parameter_declaration (type_identifier) (reference_declarator (identifier))))))
|
||||
|
||||
(comment)
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(argument_list (field_expression (identifier) (field_identifier)))))
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(initializer_list (identifier)))))
|
||||
|
||||
================================================
|
||||
template classes vs relational expressions
|
||||
================================================
|
||||
|
||||
int main() {
|
||||
T1<T2> v1;
|
||||
T1<T2> v2 = v3;
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit (function_definition
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list))
|
||||
(compound_statement
|
||||
(declaration
|
||||
(template_type (type_identifier)
|
||||
(template_argument_list (type_descriptor (type_identifier))))
|
||||
(identifier))
|
||||
(declaration
|
||||
(template_type (type_identifier)
|
||||
(template_argument_list (type_descriptor (type_identifier))))
|
||||
(init_declarator (identifier) (identifier))))))
|
||||
@@ -0,0 +1,607 @@
|
||||
================================================================================
|
||||
Concept definition
|
||||
================================================================================
|
||||
|
||||
template <class T, class U>
|
||||
concept Derived = std::is_base_of<U, T>::value;
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(translation_unit
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier))
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(concept_definition
|
||||
(identifier)
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(qualified_identifier
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))
|
||||
(type_descriptor
|
||||
(type_identifier))))
|
||||
(identifier))))))
|
||||
|
||||
================================================================================
|
||||
Concept definition with requires expression
|
||||
================================================================================
|
||||
|
||||
template<typename T>
|
||||
concept Hashable = requires(T a) {
|
||||
{ std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
|
||||
};
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(translation_unit
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(concept_definition
|
||||
(identifier)
|
||||
(requires_expression
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier)))
|
||||
(requirement_seq
|
||||
(compound_requirement
|
||||
(call_expression
|
||||
(compound_literal_expression
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)))))
|
||||
(initializer_list))
|
||||
(argument_list
|
||||
(identifier)))
|
||||
(trailing_return_type
|
||||
(type_descriptor
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(type_identifier))))))))))))))
|
||||
|
||||
================================================================================
|
||||
Requires clauses and expressions
|
||||
================================================================================
|
||||
|
||||
template<typename T>
|
||||
void f(T&&) requires Eq<T>; // can appear as the last element of a function declarator
|
||||
|
||||
template<typename T> requires Addable<T> // or right after a template parameter list
|
||||
T add(T a, T b) { return a + b; }
|
||||
|
||||
template<typename T>
|
||||
concept Addable = requires (T x) { x + x; }; // requires-expression
|
||||
|
||||
template<typename T>
|
||||
requires requires (T x) { x + x; } // ad-hoc constraint, note keyword used twice
|
||||
T add(T a, T b) { return a + b; }
|
||||
|
||||
template<typename T>
|
||||
requires (!std::is_same_v<T, bool>) // parenthesized expressions are allowed
|
||||
void f(T);
|
||||
|
||||
template<typename T> requires Addable<T> && Subtractable<T> // conjunctions
|
||||
T f(T);
|
||||
|
||||
template<typename T> requires Addable<T> || Subtractable<T> // disjunctions
|
||||
T f(T);
|
||||
|
||||
template<typename T> requires false || true // boolean literals
|
||||
T f(T);
|
||||
|
||||
template<typename... T> requires (... && Addable<T>) // fold expressions
|
||||
T f(T);
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(translation_unit
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(abstract_reference_declarator)))
|
||||
(requires_clause
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))))))
|
||||
(comment)
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(requires_clause
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)))))
|
||||
(comment)
|
||||
(function_definition
|
||||
(type_identifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier))
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier))))
|
||||
(compound_statement
|
||||
(return_statement
|
||||
(binary_expression
|
||||
(identifier)
|
||||
(identifier))))))
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(concept_definition
|
||||
(identifier)
|
||||
(requires_expression
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier)))
|
||||
(requirement_seq
|
||||
(simple_requirement
|
||||
(binary_expression
|
||||
(identifier)
|
||||
(identifier)))))))
|
||||
(comment)
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(requires_clause
|
||||
(requires_expression
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier)))
|
||||
(requirement_seq
|
||||
(simple_requirement
|
||||
(binary_expression
|
||||
(identifier)
|
||||
(identifier))))))
|
||||
(comment)
|
||||
(function_definition
|
||||
(type_identifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier))
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier))))
|
||||
(compound_statement
|
||||
(return_statement
|
||||
(binary_expression
|
||||
(identifier)
|
||||
(identifier))))))
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(requires_clause
|
||||
(unary_expression
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_function
|
||||
(identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))
|
||||
(type_descriptor
|
||||
(primitive_type)))))))
|
||||
(comment)
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier))))))
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(requires_clause
|
||||
(constraint_conjunction
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))))
|
||||
(comment)
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier))))))
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(requires_clause
|
||||
(constraint_disjunction
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))))
|
||||
(comment)
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier))))))
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(requires_clause
|
||||
(constraint_disjunction
|
||||
(false)
|
||||
(true)))
|
||||
(comment)
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier))))))
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(variadic_type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(requires_clause
|
||||
(fold_expression
|
||||
(template_function
|
||||
(identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))))
|
||||
(comment)
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)))))))
|
||||
|
||||
================================================================================
|
||||
Compound requirements
|
||||
================================================================================
|
||||
|
||||
template<typename T> concept C2 =
|
||||
requires(T x) {
|
||||
{*x} -> std::convertible_to<typename T::inner>; // the expression *x must be valid
|
||||
// AND the type T::inner must be valid
|
||||
// AND the result of *x must be convertible to T::inner
|
||||
{x + 1} -> std::same_as<int>; // the expression x + 1 must be valid
|
||||
// AND std::same_as<decltype((x + 1)), int> must be satisfied
|
||||
// i.e., (x + 1) must be a prvalue of type int
|
||||
{x * 1} -> std::convertible_to<T>; // the expression x * 1 must be valid
|
||||
// AND its result must be convertible to T
|
||||
};
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(translation_unit
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(concept_definition
|
||||
(identifier)
|
||||
(requires_expression
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier)))
|
||||
(requirement_seq
|
||||
(compound_requirement
|
||||
(pointer_expression
|
||||
(identifier))
|
||||
(trailing_return_type
|
||||
(type_descriptor
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(dependent_type
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(type_identifier))))))))))
|
||||
(comment)
|
||||
(comment)
|
||||
(comment)
|
||||
(compound_requirement
|
||||
(binary_expression
|
||||
(identifier)
|
||||
(number_literal))
|
||||
(trailing_return_type
|
||||
(type_descriptor
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(primitive_type))))))))
|
||||
(comment)
|
||||
(comment)
|
||||
(comment)
|
||||
(compound_requirement
|
||||
(binary_expression
|
||||
(identifier)
|
||||
(number_literal))
|
||||
(trailing_return_type
|
||||
(type_descriptor
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))))))
|
||||
(comment)
|
||||
(comment))))))
|
||||
|
||||
================================================================================
|
||||
Nested requirements
|
||||
================================================================================
|
||||
|
||||
template <class T>
|
||||
concept Semiregular = DefaultConstructible<T> &&
|
||||
CopyConstructible<T> && Destructible<T> && CopyAssignable<T> &&
|
||||
requires(T a, size_t n) {
|
||||
requires Same<T*, decltype(&a)>; // nested: "Same<...> evaluates to true"
|
||||
{ a.~T() } noexcept; // compound: "a.~T()" is a valid expression that doesn't throw
|
||||
requires Same<T*, decltype(new T)>; // nested: "Same<...> evaluates to true"
|
||||
requires Same<T*, decltype(new T[n])>; // nested
|
||||
{ delete new T }; // compound
|
||||
{ delete new T[n] }; // compound
|
||||
};
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(translation_unit
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration
|
||||
(type_identifier)))
|
||||
(concept_definition
|
||||
(identifier)
|
||||
(binary_expression
|
||||
(binary_expression
|
||||
(binary_expression
|
||||
(binary_expression
|
||||
(template_function
|
||||
(identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))
|
||||
(template_function
|
||||
(identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)))))
|
||||
(template_function
|
||||
(identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)))))
|
||||
(template_function
|
||||
(identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)))))
|
||||
(requires_expression
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier))
|
||||
(parameter_declaration
|
||||
(primitive_type)
|
||||
(identifier)))
|
||||
(requirement_seq
|
||||
(simple_requirement
|
||||
(requires_clause
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)
|
||||
(abstract_pointer_declarator))
|
||||
(type_descriptor
|
||||
(decltype
|
||||
(pointer_expression
|
||||
(identifier))))))))
|
||||
(comment)
|
||||
(compound_requirement
|
||||
(call_expression
|
||||
(field_expression
|
||||
(identifier)
|
||||
(destructor_name
|
||||
(identifier)))
|
||||
(argument_list)))
|
||||
(comment)
|
||||
(simple_requirement
|
||||
(requires_clause
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)
|
||||
(abstract_pointer_declarator))
|
||||
(type_descriptor
|
||||
(decltype
|
||||
(new_expression
|
||||
(type_identifier))))))))
|
||||
(comment)
|
||||
(simple_requirement
|
||||
(requires_clause
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)
|
||||
(abstract_pointer_declarator))
|
||||
(type_descriptor
|
||||
(decltype
|
||||
(new_expression
|
||||
(type_identifier)
|
||||
(new_declarator
|
||||
(identifier)))))))))
|
||||
(comment)
|
||||
(compound_requirement
|
||||
(delete_expression
|
||||
(new_expression
|
||||
(type_identifier))))
|
||||
(comment)
|
||||
(compound_requirement
|
||||
(delete_expression
|
||||
(new_expression
|
||||
(type_identifier)
|
||||
(new_declarator
|
||||
(identifier)))))
|
||||
(comment)))))))
|
||||
|
||||
================================================================================
|
||||
Constraints
|
||||
================================================================================
|
||||
|
||||
template <EqualityComparable T>
|
||||
void f(const T&); // constrained function template declaration
|
||||
|
||||
void f(const EqualityComparable auto&); // constrained function template declaration
|
||||
|
||||
Sortable auto foo = f();
|
||||
Sortable<T> auto bar = g();
|
||||
NS::Concept<T> auto baz = h();
|
||||
|
||||
Sortable decltype(auto) foo = i();
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(parameter_declaration
|
||||
(type_identifier)
|
||||
(identifier)))
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_qualifier)
|
||||
(type_identifier)
|
||||
(abstract_reference_declarator))))))
|
||||
(comment)
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration
|
||||
(type_qualifier)
|
||||
(placeholder_type_specifier
|
||||
(type_identifier)
|
||||
(auto))
|
||||
(abstract_reference_declarator)))))
|
||||
(comment)
|
||||
(declaration
|
||||
(placeholder_type_specifier
|
||||
(type_identifier)
|
||||
(auto))
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(call_expression
|
||||
(identifier)
|
||||
(argument_list))))
|
||||
(declaration
|
||||
(placeholder_type_specifier
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier))))
|
||||
(auto))
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(call_expression
|
||||
(identifier)
|
||||
(argument_list))))
|
||||
(declaration
|
||||
(placeholder_type_specifier
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)))))
|
||||
(auto))
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(call_expression
|
||||
(identifier)
|
||||
(argument_list))))
|
||||
(declaration
|
||||
(placeholder_type_specifier
|
||||
(type_identifier)
|
||||
(decltype
|
||||
(auto)))
|
||||
(init_declarator
|
||||
(identifier)
|
||||
(call_expression
|
||||
(identifier)
|
||||
(argument_list)))))
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,243 @@
|
||||
=====================================
|
||||
Scoped function definitions
|
||||
=====================================
|
||||
|
||||
int T::foo() { return 1; }
|
||||
int T::foo() const { return 0; }
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(primitive_type)
|
||||
(function_declarator
|
||||
(qualified_identifier (namespace_identifier) (identifier))
|
||||
(parameter_list))
|
||||
(compound_statement (return_statement (number_literal))))
|
||||
(function_definition
|
||||
(primitive_type)
|
||||
(function_declarator
|
||||
(qualified_identifier (namespace_identifier) (identifier))
|
||||
(parameter_list)
|
||||
(type_qualifier))
|
||||
(compound_statement (return_statement (number_literal)))))
|
||||
|
||||
=====================================
|
||||
Constructor definitions
|
||||
=====================================
|
||||
|
||||
T::T() {}
|
||||
|
||||
T::T() : f1(0), f2(1, 2) {
|
||||
puts("HI");
|
||||
}
|
||||
|
||||
T::T() : Base<T>() {}
|
||||
|
||||
T::T() try : f1(0) {} catch(...) {}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(function_declarator
|
||||
(qualified_identifier (namespace_identifier) (identifier))
|
||||
(parameter_list))
|
||||
(compound_statement))
|
||||
(function_definition
|
||||
(function_declarator
|
||||
(qualified_identifier (namespace_identifier) (identifier))
|
||||
(parameter_list))
|
||||
(field_initializer_list
|
||||
(field_initializer (field_identifier) (argument_list (number_literal)))
|
||||
(field_initializer (field_identifier) (argument_list (number_literal) (number_literal))))
|
||||
(compound_statement
|
||||
(expression_statement (call_expression (identifier) (argument_list (string_literal))))))
|
||||
(function_definition
|
||||
(function_declarator
|
||||
(qualified_identifier (namespace_identifier) (identifier))
|
||||
(parameter_list))
|
||||
(field_initializer_list
|
||||
(field_initializer
|
||||
(template_method
|
||||
(field_identifier)
|
||||
(template_argument_list (type_descriptor (type_identifier))))
|
||||
(argument_list)))
|
||||
(compound_statement))
|
||||
(function_definition
|
||||
(function_declarator
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(identifier))
|
||||
(parameter_list))
|
||||
(try_statement
|
||||
(field_initializer_list
|
||||
(field_initializer
|
||||
(field_identifier)
|
||||
(argument_list
|
||||
(number_literal))))
|
||||
(compound_statement)
|
||||
(catch_clause
|
||||
(parameter_list)
|
||||
(compound_statement)))))
|
||||
|
||||
=====================================
|
||||
Explicit constructor definitions
|
||||
=====================================
|
||||
|
||||
class C {
|
||||
explicit C(int f) : f_(f) {}
|
||||
|
||||
private:
|
||||
int f_;
|
||||
};
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(class_specifier
|
||||
(type_identifier)
|
||||
(field_declaration_list
|
||||
(function_definition
|
||||
(explicit_function_specifier)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list (parameter_declaration (primitive_type) (identifier))))
|
||||
(field_initializer_list
|
||||
(field_initializer (field_identifier) (argument_list (identifier))))
|
||||
(compound_statement))
|
||||
(access_specifier)
|
||||
(field_declaration (primitive_type) (field_identifier)))))
|
||||
|
||||
=====================================
|
||||
Explicit constructor declaration
|
||||
=====================================
|
||||
|
||||
class C {
|
||||
explicit C(int f);
|
||||
explicit(true) C(long f);
|
||||
};
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(class_specifier
|
||||
(type_identifier)
|
||||
(field_declaration_list
|
||||
(declaration
|
||||
(explicit_function_specifier)
|
||||
(function_declarator (identifier) (parameter_list (parameter_declaration (primitive_type) (identifier)))))
|
||||
(declaration
|
||||
(explicit_function_specifier (true))
|
||||
(function_declarator (identifier) (parameter_list (parameter_declaration (sized_type_specifier) (identifier))))))))
|
||||
|
||||
=====================================
|
||||
Default and deleted methods
|
||||
=====================================
|
||||
|
||||
class A : public B {
|
||||
A() = default;
|
||||
A(A &&) = delete;
|
||||
void f() = delete;
|
||||
A& operator=(const A&) = default;
|
||||
A& operator=(A&&) = delete;
|
||||
};
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(class_specifier
|
||||
(type_identifier)
|
||||
(base_class_clause (type_identifier))
|
||||
(field_declaration_list
|
||||
(function_definition
|
||||
(function_declarator (identifier) (parameter_list))
|
||||
(default_method_clause))
|
||||
(function_definition
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list (parameter_declaration (type_identifier) (abstract_reference_declarator))))
|
||||
(delete_method_clause))
|
||||
(function_definition
|
||||
(primitive_type)
|
||||
(function_declarator (field_identifier) (parameter_list)) (delete_method_clause))
|
||||
(function_definition
|
||||
(type_identifier)
|
||||
(reference_declarator
|
||||
(function_declarator
|
||||
(operator_name)
|
||||
(parameter_list (parameter_declaration (type_qualifier) (type_identifier) (abstract_reference_declarator)))))
|
||||
(default_method_clause))
|
||||
(function_definition
|
||||
(type_identifier)
|
||||
(reference_declarator
|
||||
(function_declarator
|
||||
(operator_name)
|
||||
(parameter_list (parameter_declaration (type_identifier) (abstract_reference_declarator)))))
|
||||
(delete_method_clause)))))
|
||||
|
||||
=====================================
|
||||
Destructor definitions
|
||||
=====================================
|
||||
|
||||
~T() {}
|
||||
T::~T() {}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(function_declarator (destructor_name (identifier)) (parameter_list))
|
||||
(compound_statement))
|
||||
(function_definition
|
||||
(function_declarator
|
||||
(qualified_identifier (namespace_identifier) (destructor_name (identifier))) (parameter_list))
|
||||
(compound_statement)))
|
||||
|
||||
=====================================
|
||||
Function-try-block definitions
|
||||
=====================================
|
||||
|
||||
void foo() try {} catch(...) {}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(primitive_type)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list))
|
||||
(try_statement
|
||||
(compound_statement)
|
||||
(catch_clause
|
||||
(parameter_list)
|
||||
(compound_statement)))))
|
||||
|
||||
|
||||
=====================================
|
||||
Conversion operator definitions
|
||||
=====================================
|
||||
|
||||
T::operator int() try { throw 1; } catch (...) { return 2; }
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(operator_cast
|
||||
(primitive_type)
|
||||
(abstract_function_declarator
|
||||
(parameter_list))))
|
||||
(try_statement
|
||||
(compound_statement
|
||||
(throw_statement
|
||||
(number_literal)))
|
||||
(catch_clause
|
||||
(parameter_list)
|
||||
(compound_statement
|
||||
(return_statement
|
||||
(number_literal)))))))
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,32 @@
|
||||
================================
|
||||
declaration specs
|
||||
================================
|
||||
|
||||
struct __declspec(dllexport) s2
|
||||
{
|
||||
};
|
||||
|
||||
union __declspec(noinline) u2 {
|
||||
};
|
||||
|
||||
class __declspec(uuid) u2 {
|
||||
};
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(struct_specifier
|
||||
(ms_declspec_modifier
|
||||
(identifier))
|
||||
name: (type_identifier)
|
||||
body: (field_declaration_list))
|
||||
(union_specifier
|
||||
(ms_declspec_modifier
|
||||
(identifier))
|
||||
name: (type_identifier)
|
||||
body: (field_declaration_list))
|
||||
(class_specifier
|
||||
(ms_declspec_modifier
|
||||
(identifier))
|
||||
name: (type_identifier)
|
||||
body: (field_declaration_list)))
|
||||
@@ -0,0 +1,433 @@
|
||||
===========================================
|
||||
Returning braced initializer lists
|
||||
===========================================
|
||||
|
||||
T main() {
|
||||
return {0, 5};
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(type_identifier)
|
||||
(function_declarator (identifier) (parameter_list))
|
||||
(compound_statement
|
||||
(return_statement (initializer_list (number_literal) (number_literal))))))
|
||||
|
||||
===========================================
|
||||
Range-based for loops
|
||||
===========================================
|
||||
|
||||
T main() {
|
||||
for (Value &value : values) {
|
||||
cout << value;
|
||||
}
|
||||
|
||||
for (const auto &value : values) {
|
||||
cout << value;
|
||||
}
|
||||
|
||||
for (const auto &value : {1, 2, 3}) {
|
||||
cout << value;
|
||||
}
|
||||
|
||||
for (auto n = v.size(); auto i : v) {
|
||||
cout << --n + i << ' ';
|
||||
}
|
||||
|
||||
for (using elem_t = T::value_type; elem_t i : v) {
|
||||
cout << --n + i << ' ';
|
||||
}
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
type: (type_identifier)
|
||||
declarator: (function_declarator
|
||||
declarator: (identifier)
|
||||
parameters: (parameter_list))
|
||||
body: (compound_statement
|
||||
(for_range_loop
|
||||
type: (type_identifier)
|
||||
declarator: (reference_declarator (identifier))
|
||||
right: (identifier)
|
||||
body: (compound_statement
|
||||
(expression_statement (binary_expression
|
||||
left: (identifier)
|
||||
right: (identifier)))))
|
||||
(for_range_loop
|
||||
(type_qualifier)
|
||||
type: (placeholder_type_specifier (auto))
|
||||
declarator: (reference_declarator (identifier))
|
||||
right: (identifier)
|
||||
body: (compound_statement
|
||||
(expression_statement (binary_expression
|
||||
left: (identifier)
|
||||
right: (identifier)))))
|
||||
(for_range_loop
|
||||
(type_qualifier)
|
||||
type: (placeholder_type_specifier (auto))
|
||||
declarator: (reference_declarator (identifier))
|
||||
right: (initializer_list (number_literal) (number_literal) (number_literal))
|
||||
body: (compound_statement
|
||||
(expression_statement (binary_expression
|
||||
left: (identifier)
|
||||
right: (identifier)))))
|
||||
(for_range_loop
|
||||
initializer: (init_statement
|
||||
(declaration
|
||||
type: (placeholder_type_specifier (auto))
|
||||
declarator: (init_declarator
|
||||
declarator: (identifier)
|
||||
value: (call_expression
|
||||
function: (field_expression
|
||||
argument: (identifier)
|
||||
field: (field_identifier))
|
||||
arguments: (argument_list)))))
|
||||
type: (placeholder_type_specifier (auto))
|
||||
declarator: (identifier)
|
||||
right: (identifier)
|
||||
body: (compound_statement
|
||||
(expression_statement
|
||||
(binary_expression
|
||||
left: (binary_expression
|
||||
left: (identifier)
|
||||
right: (binary_expression
|
||||
left: (update_expression
|
||||
argument: (identifier))
|
||||
right: (identifier)))
|
||||
right: (char_literal)))))
|
||||
(for_range_loop
|
||||
initializer: (init_statement
|
||||
(alias_declaration
|
||||
name: (type_identifier)
|
||||
type: (type_descriptor
|
||||
type: (qualified_identifier
|
||||
scope: (namespace_identifier)
|
||||
name: (type_identifier)))))
|
||||
type: (type_identifier)
|
||||
declarator: (identifier)
|
||||
right: (identifier)
|
||||
body: (compound_statement
|
||||
(expression_statement
|
||||
(binary_expression
|
||||
left: (binary_expression
|
||||
left: (identifier)
|
||||
right: (binary_expression
|
||||
left: (update_expression
|
||||
argument: (identifier))
|
||||
right: (identifier)))
|
||||
right: (char_literal))))))))
|
||||
|
||||
===========================================
|
||||
Constexpr if statements
|
||||
===========================================
|
||||
|
||||
T f() {
|
||||
if constexpr (std::is_pointer_v<T>)
|
||||
return *t;
|
||||
else
|
||||
return t;
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
type: (type_identifier)
|
||||
declarator: (function_declarator
|
||||
declarator: (identifier)
|
||||
parameters: (parameter_list))
|
||||
body: (compound_statement
|
||||
(if_statement
|
||||
condition: (condition_clause
|
||||
value: (qualified_identifier
|
||||
scope: (namespace_identifier)
|
||||
name: (template_function
|
||||
name: (identifier)
|
||||
arguments: (template_argument_list
|
||||
(type_descriptor type: (type_identifier))))))
|
||||
consequence: (return_statement
|
||||
(pointer_expression argument: (identifier)))
|
||||
alternative: (return_statement (identifier))))))
|
||||
|
||||
=====================================
|
||||
If statements with declarations
|
||||
====================================
|
||||
|
||||
void f() {
|
||||
if (const int x = foo()) { }
|
||||
if (const int x { foo() }) { }
|
||||
if (const int x = foo(); x != 0) { }
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
type: (primitive_type)
|
||||
declarator: (function_declarator
|
||||
declarator: (identifier)
|
||||
parameters: (parameter_list))
|
||||
body: (compound_statement
|
||||
(if_statement
|
||||
condition: (condition_clause
|
||||
value: (declaration
|
||||
(type_qualifier)
|
||||
type: (primitive_type)
|
||||
declarator: (identifier)
|
||||
value: (call_expression
|
||||
function: (identifier)
|
||||
arguments: (argument_list))))
|
||||
consequence: (compound_statement))
|
||||
(if_statement
|
||||
condition: (condition_clause
|
||||
value: (declaration
|
||||
(type_qualifier)
|
||||
type: (primitive_type)
|
||||
declarator: (identifier)
|
||||
value: (initializer_list (call_expression function: (identifier) arguments: (argument_list)))))
|
||||
consequence: (compound_statement))
|
||||
(if_statement
|
||||
condition: (condition_clause
|
||||
initializer: (init_statement
|
||||
(declaration
|
||||
(type_qualifier)
|
||||
type: (primitive_type)
|
||||
declarator: (init_declarator
|
||||
declarator: (identifier)
|
||||
value: (call_expression function: (identifier) arguments: (argument_list)))))
|
||||
value: (binary_expression left: (identifier) right: (number_literal)))
|
||||
consequence: (compound_statement)))))
|
||||
|
||||
===========================================
|
||||
Try/catch statements
|
||||
===========================================
|
||||
|
||||
void main() {
|
||||
try {
|
||||
f();
|
||||
} catch (const std::overflow_error) {
|
||||
// f() throws std::overflow_error (same type rule)
|
||||
} catch (const exception &e) {
|
||||
// f() throws std::logic_error (base class rule)
|
||||
} catch (...) {
|
||||
// f() throws std::string or int or any other unrelated type
|
||||
}
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list))
|
||||
(compound_statement
|
||||
(try_statement
|
||||
(compound_statement
|
||||
(expression_statement (call_expression (identifier) (argument_list))))
|
||||
(catch_clause
|
||||
(parameter_list (parameter_declaration (type_qualifier) (qualified_identifier (namespace_identifier) (type_identifier))))
|
||||
(compound_statement (comment)))
|
||||
(catch_clause
|
||||
(parameter_list (parameter_declaration (type_qualifier) (type_identifier) (reference_declarator (identifier))))
|
||||
(compound_statement (comment)))
|
||||
(catch_clause
|
||||
(parameter_list)
|
||||
(compound_statement (comment)))))))
|
||||
|
||||
===========================================
|
||||
Throw statements
|
||||
===========================================
|
||||
|
||||
void main() {
|
||||
throw e;
|
||||
throw x + 1;
|
||||
throw "exception";
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(primitive_type)
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list))
|
||||
(compound_statement
|
||||
(throw_statement (identifier))
|
||||
(throw_statement (binary_expression (identifier) (number_literal)))
|
||||
(throw_statement (string_literal)))))
|
||||
|
||||
===========================================
|
||||
Noexcept specifier
|
||||
===========================================
|
||||
|
||||
void foo() noexcept;
|
||||
void foo() noexcept(true);
|
||||
template<class T> T foo() noexcept(sizeof(T) < 4);
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list)
|
||||
(noexcept)))
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list)
|
||||
(noexcept (true))))
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration (type_identifier)))
|
||||
(declaration
|
||||
(type_identifier)
|
||||
(function_declarator (identifier) (parameter_list)
|
||||
(noexcept
|
||||
(binary_expression (sizeof_expression (parenthesized_expression (identifier))) (number_literal)))))))
|
||||
|
||||
===========================================
|
||||
Throw specifier
|
||||
===========================================
|
||||
|
||||
void foo() throw();
|
||||
void foo() throw(int);
|
||||
void foo() throw(std::string, char *);
|
||||
void foo() throw(float) { }
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list)
|
||||
(throw_specifier)))
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list)
|
||||
(throw_specifier (type_descriptor (primitive_type)))))
|
||||
(declaration
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list)
|
||||
(throw_specifier
|
||||
(type_descriptor (qualified_identifier (namespace_identifier) (type_identifier)))
|
||||
(type_descriptor (primitive_type) (abstract_pointer_declarator)))))
|
||||
(function_definition
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list)
|
||||
(throw_specifier (type_descriptor (primitive_type))))
|
||||
(compound_statement)))
|
||||
|
||||
===========================================
|
||||
Assignment
|
||||
===========================================
|
||||
|
||||
a::b::c = 1;
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(expression_statement
|
||||
(assignment_expression
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(identifier)))
|
||||
(number_literal))))
|
||||
|
||||
=========================================
|
||||
Attributes
|
||||
=========================================
|
||||
|
||||
void f() {
|
||||
[[a]] switch (b) {
|
||||
[[c]] case 1: {}
|
||||
}
|
||||
[[a]] while (true) {}
|
||||
[[a]] if (true) {}
|
||||
[[a]] for (auto x : y) {}
|
||||
[[a]] for (;;) {}
|
||||
[[a]] return;
|
||||
[[a]] a;
|
||||
[[a]];
|
||||
[[a]] label: {}
|
||||
[[a]] goto label;
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition (primitive_type)
|
||||
(function_declarator (identifier) (parameter_list))
|
||||
(compound_statement
|
||||
(attributed_statement (attribute_declaration (attribute (identifier)))
|
||||
(switch_statement
|
||||
(condition_clause (identifier))
|
||||
(compound_statement
|
||||
(attributed_statement (attribute_declaration (attribute (identifier)))
|
||||
(case_statement (number_literal) (compound_statement))))))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (while_statement (condition_clause (true)) (compound_statement)))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (if_statement (condition_clause (true)) (compound_statement)))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (for_range_loop (placeholder_type_specifier (auto)) (identifier) (identifier) (compound_statement)))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (for_statement (compound_statement)))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (return_statement))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (expression_statement (identifier)))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (expression_statement))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (labeled_statement (statement_identifier) (compound_statement)))
|
||||
(attributed_statement (attribute_declaration (attribute (identifier))) (goto_statement (statement_identifier))))))
|
||||
|
||||
===========================================
|
||||
Coroutines
|
||||
===========================================
|
||||
|
||||
co_return 1;
|
||||
co_return;
|
||||
co_yield 1;
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(co_return_statement
|
||||
(number_literal))
|
||||
(co_return_statement)
|
||||
(co_yield_statement
|
||||
(number_literal)))
|
||||
|
||||
|
||||
===========================================
|
||||
Switch statements
|
||||
===========================================
|
||||
|
||||
void foo(int a) {
|
||||
switch (a) {
|
||||
case 1:
|
||||
for (auto i : vec) {}
|
||||
case 2:
|
||||
try {
|
||||
// do something
|
||||
} catch(...) {}
|
||||
throw 1;
|
||||
case 3:
|
||||
co_return;
|
||||
default:
|
||||
co_yield a;
|
||||
}
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition (primitive_type)
|
||||
(function_declarator (identifier) (parameter_list (parameter_declaration (primitive_type) (identifier))))
|
||||
(compound_statement
|
||||
(switch_statement (condition_clause (identifier))
|
||||
(compound_statement
|
||||
(case_statement (number_literal) (for_range_loop (placeholder_type_specifier (auto)) (identifier) (identifier) (compound_statement)))
|
||||
(case_statement (number_literal) (try_statement (compound_statement (comment)) (catch_clause (parameter_list) (compound_statement))) (throw_statement (number_literal)))
|
||||
(case_statement (number_literal) (co_return_statement))
|
||||
(case_statement (co_yield_statement (identifier))))))))
|
||||
@@ -0,0 +1,177 @@
|
||||
==========================================
|
||||
The auto type
|
||||
==========================================
|
||||
|
||||
void foo() {
|
||||
auto x = 1;
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(primitive_type)
|
||||
(function_declarator (identifier) (parameter_list))
|
||||
(compound_statement
|
||||
(declaration (placeholder_type_specifier (auto)) (init_declarator (identifier) (number_literal))))))
|
||||
|
||||
==========================================
|
||||
Namespaced types
|
||||
==========================================
|
||||
|
||||
std::string my_string;
|
||||
std::vector<int>::size_typ my_string;
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(declaration
|
||||
(qualified_identifier (namespace_identifier) (type_identifier))
|
||||
(identifier))
|
||||
(declaration
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(qualified_identifier
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list (type_descriptor (primitive_type))))
|
||||
(type_identifier)))
|
||||
(identifier)))
|
||||
|
||||
==========================================
|
||||
Dependent type names
|
||||
==========================================
|
||||
|
||||
template<typename T>
|
||||
struct X : B<T>
|
||||
{
|
||||
typename T::A* pa;
|
||||
};
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(template_declaration
|
||||
(template_parameter_list (type_parameter_declaration (type_identifier)))
|
||||
(struct_specifier
|
||||
(type_identifier)
|
||||
(base_class_clause
|
||||
(template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier)))))
|
||||
(field_declaration_list
|
||||
(field_declaration
|
||||
(dependent_type (qualified_identifier (namespace_identifier) (type_identifier)))
|
||||
(pointer_declarator (field_identifier)))))))
|
||||
|
||||
==========================================
|
||||
Template types with empty argument lists
|
||||
==========================================
|
||||
|
||||
use_future_t<> use_future;
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(declaration (template_type (type_identifier) (template_argument_list)) (identifier)))
|
||||
|
||||
================================
|
||||
Function types as template arguments
|
||||
================================
|
||||
|
||||
typedef std::function<T(int)> MyFunc;
|
||||
typedef std::function<void(int)> b;
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(type_definition
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(type_identifier)
|
||||
(abstract_function_declarator (parameter_list
|
||||
(parameter_declaration (primitive_type))))))))
|
||||
(type_identifier))
|
||||
(type_definition
|
||||
(qualified_identifier
|
||||
(namespace_identifier)
|
||||
(template_type
|
||||
(type_identifier)
|
||||
(template_argument_list
|
||||
(type_descriptor
|
||||
(primitive_type)
|
||||
(abstract_function_declarator (parameter_list
|
||||
(parameter_declaration (primitive_type))))))))
|
||||
(type_identifier)))
|
||||
|
||||
====================================================
|
||||
Decltype
|
||||
====================================================
|
||||
|
||||
decltype(A) x;
|
||||
decltype(B) foo(void x, decltype(C) y);
|
||||
template<typename T, typename U> auto add(T t, U u) -> decltype(t + u);
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(declaration
|
||||
(decltype (identifier))
|
||||
(identifier))
|
||||
(declaration
|
||||
(decltype (identifier))
|
||||
(function_declarator (identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration (primitive_type) (identifier))
|
||||
(parameter_declaration (decltype (identifier)) (identifier)))))
|
||||
(template_declaration
|
||||
(template_parameter_list
|
||||
(type_parameter_declaration (type_identifier)) (type_parameter_declaration (type_identifier)))
|
||||
(declaration
|
||||
(placeholder_type_specifier (auto))
|
||||
(function_declarator
|
||||
(identifier)
|
||||
(parameter_list
|
||||
(parameter_declaration (type_identifier) (identifier))
|
||||
(parameter_declaration (type_identifier) (identifier)))
|
||||
(trailing_return_type
|
||||
(type_descriptor
|
||||
(decltype (binary_expression (identifier) (identifier)))))))))
|
||||
|
||||
====================================================
|
||||
Trailing return type
|
||||
====================================================
|
||||
|
||||
auto a::foo() const -> const A<B>& {}
|
||||
auto b::foo() const -> A<B> const& {}
|
||||
|
||||
---
|
||||
|
||||
(translation_unit
|
||||
(function_definition
|
||||
(placeholder_type_specifier (auto))
|
||||
(function_declarator
|
||||
(qualified_identifier (namespace_identifier) (identifier))
|
||||
(parameter_list)
|
||||
(type_qualifier)
|
||||
(trailing_return_type
|
||||
(type_descriptor
|
||||
(type_qualifier)
|
||||
(template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier))))
|
||||
(abstract_reference_declarator))))
|
||||
(compound_statement))
|
||||
(function_definition
|
||||
(placeholder_type_specifier (auto))
|
||||
(function_declarator
|
||||
(qualified_identifier (namespace_identifier) (identifier))
|
||||
(parameter_list)
|
||||
(type_qualifier)
|
||||
(trailing_return_type
|
||||
(type_descriptor
|
||||
(template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier))))
|
||||
(type_qualifier)
|
||||
(abstract_reference_declarator))))
|
||||
(compound_statement))
|
||||
)
|
||||
Reference in New Issue
Block a user