2015-05-22 Andrew Sutton <andrew.n.sutton@gmail.com>

[official-gcc.git] / ChangeLog.concepts

2015-05-22  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix regression caused by null de-reference.
        * gcc/cp/decl.c (xref_tag_1): Check that current_template_parms
        is non-null before accessing constraints.

2015-05-19  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Handle nested requirements with type errors.
        * gcc/cp/constraint.cc (constraint_p): Admit error_mark_node
        as a valid, but never satisfied, constraint.
        (normalize_constraint): Handle the error_mark_node case.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_constraint): Likewise.
        * gcc/testsuite/g++.dg/concepts/fn10.C: New test case.

2015-05-19  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Stop template processing during constraint satisfication.
        * gcc/cp/constraint.cc (satisfy_constraint): Rename to
        satisfy_constraint_1 and assert that we are not processing
        template declarations.
        (satisfy_*_constraint): Use satisfy_constraint_1.
        (satisfy_constraint): Turn off template processing.
        * gcc/testsuite/g++.dg/concepts/fn10.C: New.

2015-05-19  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Handle naked non-type template arguments as constraints.
        * gcc/cp/constraint.cc (xform_misc): Removed.
        (transform_expr): All misc tree classes are atomic constraints.
        * gcc/testsuite/g++.dg/concepts/req1.C: Add new test cases.

2015-05-18  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix long-standing regression in template introductions.
        * gcc/cp/parser.c (cp_parser_template_declaration_after_export):
        Return bool.
        (cp_parser_template_parameter_list): Remove #ifdeffing.
        (cp_parser_member_declaration): Check for template introductions.
        (cp_parser_template_declaration_after_parameters): New. Parse
        a template declaration following the declaration or introduction
        of template parameters.
        (cp_parser_template_introduction): Save and restore scopes when
        tentatively parsing a template introduction. Update diagnostics.
        (cp_parser_explicit_template_declaration): Renamed from 
        cp_parser_template_declaration_after_export. Parse a template
        declartion that begins with the template keyword. Use
        cp_parser_template_declaration_after_parameters to parse the
        declaration after parsing the header.
        (cp_parser_template_declaration_after_export): Use either
        cp_parser_template_introduction or 
        cp_parser_explicit_template_declaration.
        * gcc/testsuite/g++.dg/concepts/intro4: Remove spurios diagnostic.
        * gcc/testsuite/g++.dg/concepts/intro6: New.

2015-05-08  Andrew Sutton  <andrew.n.sutton@gmail.com>

        PR66091
        * gcc/cp/cp-tree.h (get_function_declarator): New.
        * gcc/cp/decl.c (get_trailing_requires_clause): Use 
        get_function_declarator.
        * gcc/cp/parser.c (function_declarator_p): Likewise.
        (cp_parser_declarator): Stop invoking undefined behavior
        and install the requires clause on the found function 
        declarator.
        * gcc/testsuite/g++.dg/concepts/pr66091.C: New.

2015-05-08  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Addressing review comments.
        * gcc/cp/call.c (build_new_function_call): Don't check for
        template parameters when we're not processing a template decl.
        * gcc/cp/constraint.cc (function_concept_check_p): Use
        get_first_fn.
        (satisfy_expression_constraint): Move sentinel into cp-tree.h.
        * gcc/cp/parser.c (cp_parser_declarator): Use function_declarator_p.
        * gcc/cp/cp-tree.h (struct deferring_access_check_sentinel): Moved
        from constraint.cc.
        * gcc/cp/semantics: (finish_call_expr) Don't remove constraints.

2015-05-08  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Use the substituted type, not the deduced arguments, to
        check placeholder constraints.
        * gcc/cp/pt.c (do_auto_deduction): Check constraints using
        the deduced type and not the deduced arguments.
        (tsubst): Don't substitute through constraints.
        * gcc/cp/cxx-pretty-print.c (cxx_pretty_printer::expression):
        Print trait expressions.
        (pp_cxx_implicit_conversion_constraint,
        pp_cxx_argument_deduction_constraint): Clean up printing.
        * gcc/testsuite/g++.dg/concepts/placeholder2.C: Update tests
        to require extra substitutions.

2015-05-07  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Implement argument deduction constraints.
        * gcc/cp/cp-tree.def (DEDUCT_CONSTR): Add a third operand.
        * gcc/cp/cp-tree.h (auto_deduction_context): New. Flags to control
        diagnostics in auto deduction.
        (do_auto_deduction): New overload to allow for control of diagnostics.
        (tsubst_constraint): Make extern.
        * gcc/cp/pt.c (tsubst): Propagate constraints for place holders.
        (do_auto_deduction): New overload that calls the expanded version
        with default args. 
        (do_auto_deduction): Control diagnostics with tf_subst_flags and
        auto_deduction_context.
        (do_auto_deduction): Only check constraints for when not using
        decltype(auto).
        * gcc/cp/constraint.cc (xform_compound_requirement): Build argument
        deduction constraints.
        (xform_atomic): Don't check the types of dependent expressions,
        even when not processing templates.
        (satisfy_argument_deduction_constraint): Implement this.
        * gcc/testsuite/g++.dg/concepts/placeholder1.C: Add tests for
        more complex failures.
        * gcc/testsuite/g++.dg/concepts/placeholder2.C: New.

2015-05-06  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Initial implementation of constrained-type-specifiers for variable 
        declarations. Also updating documentation and style.
        * gcc/cp/cp-tree.h (make_constrained_auto): New.
        (evaluate_constraints): New.
        (check_constraint_epression): Renamed and made static.
        * gcc/cp/pt.c (do_auto_deduction): Check constraints on
        constrained placeholders before forming the type.
        * gcc/cp/parser.c (cp_parser_postfix_expression): Don't
        allow constrained-type-specifiers within the first term
        of a postfix expression.
        (cp_parser_allows_constrained_type_specifier): Removed.
        (cp_maybe_constrained_type_specifier): Don't process
        nodes as constrained type specifiers unless they look like
        constrianed type specifiers, and only when they are allowed.
        Also, support constrained auto for placeholders. Renamed 
        variables to better reflect usage.
        gcc/cp/parser.h (struct cp_parser): New member
        prevent_constrained_type_specifiers.
        gcc/cp/decl.c (grokfndecl): Remove commented code.
        gcc/cp/constraint.cc (deduce_constrained_parameter): New.
        Actually check that template arguments match the concept's 
        parameters.
        (deduce_constrained_parameter): Use deduce_constrained_parameter.
        (make_constrained_auto): New. Construct an auto with an
        attached constraint.
        (check_*_constraint): Renamed to satisfy_*_constraint.
        (satisfy_constraint): New. Simplify usage in evaluation functions.
        (evaluate_constraints): New. Normalize and evaluate a constraint.
        (constraints_satisfied_p): Allow a constraint to be used as
        an argument in addition to declaraitons.
        (constraint_expression_satisfied_p): Renamed from 
        check_constraint_expression.
        (diagnose_*): Use constraint_expression_satisfied_p.
        (diagnose_decl_constraint): New.
        (diagnose_constraint): Allow the argument to be a constraint
        in addition to a declaration.
        * gcc/testsuite/g++.dg/concepts/mem-concept.C: Renamed to
        member-concept.C. Updated tests to reflect actual errors.
        * gcc/testsuite/g++.dg/concepts/mem-concept-err.C: Removed,
        because it is redundant.
        * gcc/testsuite/g++.dg/concepts/var-concept5.C: Update error messages.
        * gcc/testsuite/g++.dg/concepts/placeholder1.C: New.

2015-05-05  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fixing errors in the invention of constrained placeholders
        and bringing the implementation more into line with the
        wording of the TS. Also, rewrite comments in C style.
        * gcc/cp/cp-tree.def (INTRODUCED_PARM_DECL): Renamed to
        WILDCARD_DECL.
        * gcc/cp/cp-tree.h (INTRODUCED_PACK_P): Renamed to
        WILDCARD_PACK_P.
        (IS_INTRODUCED_PACK): Removed.
        * cp-objcp-common.c (cp_common_init_ts): Use WILDCARD_DECL.
        * gcc/cp/pt.c (convert_placeholder_argument): Renamed to
        convert_wildcard_argument.
        (coerce_template_parameter_pack): Update for removed macro.
        gcc/cp/parser.c (cp_parser_introduction_list): Use WILDCARD_DECL.
        (cp_maybe_constrained_type_specifier): Likewise.
        (get_concept_from_constraint): Handle VAR_DECLs.
        gcc/cp/constraint.cc (contains_wildcard_p): New.
        (build_variable_check): New. Finish processing references to
        variable templates if the template-id doesn't have wildcards.
        (build_concept_check_arguments): New. Factor argument construction
        into a separate function.
        (build_template_id_check): New. Like build_concept_check, but
        guarantees preservation of template-ids.
        (build_concept_check): Use build_variable_check. Refacor to
        use build_concept_check_arguments.
        (process_introduction_parm): Use WILDCARD_DECL.
        * gcc/testsuite/g++.dg/concepts/equiv2.C: Update test.

2015-05-04  Andrew Sutton  <andrew.n.sutton@gmail.com>

        PR65854
        * gcc/cp/parser.c (cp_parser_type_requirement): Unwrap alias 
        declarations so they can be checked correctly.
        * gcc/testsuite/g++.dg/concepts/pr65854.C: New.

2015-04-22  Andrew Sutton  <andrew.n.sutton@gmail.com>

        PR65848
        * gcc/cp/cp-tree.h (function_concept_check_p): New.
        * gcc/cp/call.c (build_new_function_call): Don't evaluate
        concepts while processing a template.
        * gcc/cp/constraint.cc (function_concept_check_p): New.
        * gcc/cp/pt.c (finish_template_variable): Don't evaluate
        concepts while processing a template.
        (instantiation_dependent_r): Treat all calls to function
        concepts as instantiation dependent.
        * gcc/testsuite/g++.dg/concepts/pr65848.C: New.
        * gcc/testsuite/g++.dg/concepts/req4.C: Remove extra errors.
        * gcc/testsuite/g++.dg/concepts/req5.C: Remove extra errors.

2015-04-22  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Compare constrained partial specializations structurally.
        * gcc/pt.c (process_partial_specialization): Don't use a
        canonical type for constrained partial template specializations.
        Compare structurally to avoid ICE's when specializations resolve
        differently.

2015-04-20  Andrew Sutton  <andrew.n.sutton@gmail.com>

        PR65681
        * gcc/cp/constraint.cc (tsubst_simple_requirement): Substitute
        in a template-processing context to avoid doing full resolution
        on types and expressions.
        (tsubst_type_requirement): Likewise.
        (tsubst_compound_requirement): Likewise.
        (tsubst_nested_requirement): Likewise.
        * gcc/testsuite/g++.dg/concepts/pr65681.C: New.
        * gcc/testsuite/g++.dg/concepts/req2.C: Remove check for spurious
        diagnostics.

2015-04-20  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Improve pretty printing output for constraints
        * gcc/cp/error.c (dump_expr): Print predicate constraints
        just like other constraints.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_requirement): Add missing
        break statement.
        (pp_cxx_requirement_list): Print requirements inline instead
        of in newlines.
        (pp_cxx_requirement_body): Don't print a parameter list if
        there are no parameters.
        (pp_cxx_nested_requirement): Be less obtuse.
        (pp_cxx_expression_constraint): Likewise.
        (pp_cxx_type_constraint) Likewise.
        (pp_cxx_implicit_conversion_constraint): Likewise.
        (pp_cxx_argument_deduction_constraint): Likewise.
        (pp_cxx_parameterized_constraint): Likewise.
        (pp_cxx_conjunction): Print spaces explicitly.
        (pp_cxx_disjunction): Likewise.

2015-04-17  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Support requires-expressions for variable concepts.
        * gcc/cp/parser.c (cp_parser_requires_expression): Parse
        the parameters and body as unevaluated operands.
        * gcc/cp/pt.c (value_dependent_expression_p): Make all
        requires-expressions value dependent so we don't try to
        initialize concepts as if they were actually variables.
        * gcc/cp/tree.cp (cp_tree_equal): Remove debugging code.
        * gcc/testsuite/g++.dg/concepts/var-concept1.C: Add tests
        cases.

2015-04-14  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix bootstrap regression.
        * gcc/cp/parser.c (cp_maybe_partial_concept_id): Remove
        unused overload.

2015-04-13  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Handle partial-concept-ids for variable templates
        * gcc/cp/parser.c (cp_parser_template_id): Factor the check for
        variable templates into a new branch that preceeds the check
        for variable templates and function templates.
        * gcc/testsuite/g++.dg/concepts/partial.C: Renamed.
        * gcc/testsuite/g++.dg/concepts/partial-concept-id2.C: New.

2015-04-06  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/constraint.cc (lift_variable_concept): Coerce template
        arguments before substituting into the initializer.
        * gcc/cp/pt.c (coerce_template_parms): New overload that accepts
        a tsubst_flags_t.
        * gcc/cp/cp-tree.h (coerce_template_parms): New declaration.
        * gcc/testsuite/g++.dg/concepts/var-concept5.C: New.

2015-04-06  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/constriant.cc (check_pack_expansion): Don't check
        same_type_p if the type is null.
        * gcc/cp/pt.c (process_partial_specialization): Don't allow
        specialization of variable concepts.
        * gcc/testsuite/g++.dg/concepts/var-concepts[1-3].C: Renamed to
        var-concept[1-3].C.
        * gcc/testsuite/g++.dg/concepts/var-concept4.C: New.

2015-04-03  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        PR65635
        * gcc/cp/tree.c (cp_tree_equal): Compare type declrations when
        ordering constraints.
        * gcc/testsuite/g++.dg/concepts/pr65635: New.

2015-04-03  Andrew Sutton  <andrew.n.sutton@gmail.com>

        PR65636
        * gcc/cp/pt.c (tsubst_decl): Don't try to manage specializations
        for non-dependent, simple type declarations in namespace scope
        because they don't have C++ language extensions.
        * gcc/testsuite/g++.dg/concepts/pr65636: New.

2015-04-03  Andrew Sutton  <andrew.n.sutton@gmail.com>

        PR65634
        * gcc/cp/except.c (check_noexcept_r): Check the function type
        and not the return type for (TYPE_NOTHROW_P).
        * gcc/cp/parser.c (cp_parser_check_for_invalid_template_id): Remove
        stray debugging code.
        * gcc/testsuite/g++.dg/concepts/pr65634: New.

2015-04-02  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fixing constraint processing bugs.
        * gcc/cp/constraint.cc (check_logical_expr): Use build_x_binary_op
        so that the c-common doesn't try to fold requires-expressions.
        * gcc/cp/constexpr.c (cxx_eval_constant_expression): The value
        of a requires clause is true iff its constraints are satisfied.
        This lets us check negated requires-expressions.
        * gcc/testsuite/g++.dg/concepts/req4.C: Update diagnostics
        * gcc/testsuite/g++.dg/concepts/req5.C: Update diagnostics
        * gcc/testsuite/g++.dg/concepts/req11.C: New.

2015-03-27  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        Trying again with PR65575.
        * gcc/cp/parser.c (cp_parser_declarator): Search through
        declarator structure for likely matches for function
        declarations.
        * gcc/testsuite/g++.dg/concepts/pr65575.C: Update with
        new tests.

2015-03-25  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        PR65575.
        * gcc/cp/parser.c (cp_parser_declarator): Don't emit errors
        when a trailing requires-clause follows a non-function
        abstract declarator.
        * gcc/testsuite/g++.dg/concepts/pr65575.C: New.

2015-03-25  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix scope-squashing error in PR65552.
        * gcc/cp/parser.C (cp_parser_type_requirement): Save and
        restore scopes around optional nested name specifier parse.
        * gcc/testsuite/g++.dg/concepts/pr65552.C: New.

2015-03-24  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix bug in disjunction processing and fix the pretty
        printing for __is_same_as trait correct.
        * gcc/cp/constraint.cc (check_disjunction): Don't return
        false if the first condition fails and the second succeeds.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_trait_expr): Print the
        second argument for __is_same_as.

2015-03-24  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Make implicit conversion constraints handle usual
        conversions, not just implicit conversions.
        * gcc/cp/constraint.cc (check_implicit_conversion_constraint): 
        Use perform_direct_initialization_if_possible to test for
        converibility instead of can_convert_arg.
        * gcc/testsuite/g++.dg/concepts/req10.C: New.

2015-03-24  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Suppress errors regarding deleted functions when
        checking constriants
        * gcc/cp/pt.c (tsubst_baselink): Pass complain flags to
        mark_used.
        * gcc/testsuite/g++.dg/concepts/expression3.C: New.

2015-03-22  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix regression related to variadic templates, bugs in
        the handling of access checking, and in the logic solver.
        * gcc/cp/constraint.cc (declare_constraint_vars): Mark
        constraint variables.
        (deferring_access_check_sentinel): Make this a local class
        of check_expression_constraint.
        (check_type_constraint): Don't defer access checks. Instead
        pop deferred access checks if they fail.
        (finish_requires_expr): Mark constraint variables.
        * gcc/cp/cp-tree.h (CONSTRAINT_VAR_P): Indicates if a
        parameter is a constraint variable.
        * gcc/cp/pt.c (pending_expansion_p): New. Helps determine
        if a parameter will be expanded during substitution.
        (tsubst_pack_expansion): For certain expressions pending
        expansion, do that here.
        (tsubst_decl): Remove dead code.
        (tsubst_copy_and_build): Don't add arguments that are
        pending expansion. Also, don't build expansion when the
        type is dependent. This was causing a regression in 
        non-concepts code.
        * gcc/cp/logic.cc (proof_state::branch): Don't rely on
        order of operations. This crashed when built with Clang.
        * gcc/testsuite/g++.dg/concepts/expression2.C: Update to
        match diagnostics.

2015-03-21  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Completely suppress access violations occurring from
        constraint checks.
        * gcc/cp/constraint.cc (deferring_access_check_sentinel): New helper
        class for managing deferred access checks.
        (check_expression_constraint): Explicitly defer constraint checks.
        (check_type_constraint): Explicitly defer constraint checks.
        * gcc/testsuite/g++.dg/concepts/expression3.C: New.

2015-03-21  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fail constraints due to access violations in non-SFINAE
        contexts.
        gcc/cp/constraint.cc (check_expression_constraint,
        check_type_constraint): Check for access violations.
        gcc/cp/pt.c (tsubst_decl): Make sure that template
        info exists before dereferencing it.
        * gcc/testsuite/g++.dg/concepts/expression2.C: New.

2015-03-20  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix grammar error type requirements and improve diagnostics
        for mis-defined function concepts and errors involving pack 
        expansions.
        * gcc/cp/pt.c (determine_specialization). Remove dead code.
        (lookup_template_class_1): Return an error if constraints
        aren't satisfied.
        * gcc/cp/constraint.cc (lift_function_definition): Don't
        re-check for empty/erroneous concept definitions.
        (lift_pack_expansion): Removed. Don't inline patterns so
        that we can preserve the syntax beneath them.
        (lift_expression): Don't do anything with pack expansions.
        (check_function_concept): Specifically check for empty
        concept definitions.
        (diagnose_pack_expansion): Diagnose errors in expansions
        more thoughtfully by determining which arguments are failing
        their expanded requirements.
        gcc/cp/parser.c (cp_parser_type_requirement): Accept an
        optional template keyword before a template-id and
        parse that as a special case of required type name.
        gcc/testsuite/g++.dg/concepts/template-parm11.C: Update test
        for fixed grammar, diagnostics.

2015-03-20  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Ensure that empty expansions are satisfied.
        * gcc/cp/constraint.cc (check_pack_expansion): Empty expansions
        are satsified.
        * gcc/testsuite/g++.dg/concepts/template-parm11.C: New.

2015-03-20  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix regression in variadic constraint processing.
        * gcc/cp/pt.c (tsubst_pack_expansion): Expose declaration.
        * gcc/cp/constraint.cc: Rename lift_constraints to
        lift_expression to better reflect what it does.
        (lift_pack_expansion): New. Handles naked pack expansions
        in a constriant.
        (check_pack_expansion): Special handling for checking naked
        pack expansions in constraints. This eventually be replaced
        by similar logic for fold expressions.
        (check_predicate_constraint): Handle pack expansions.
        * gcc/cp/cp-tree.h (tsubst_pack_expansion): Make this avaialble
        to constraints.cc.

2015-03-18  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Update variable concept processing to account for changes
        in variable template syntax.
        * gcc/cp/constraint.cc (valid_predicate_p): Remove because of
        frequent triggers.
        (make_predicate_constraint): Likewise.
        (lift_function_call): Check for use of variables in function
        calls in constraints.
        (lift_call_expression): Renamed from lift_call. Specifically
        check function calls before rewriting the node.
        (lift_variable_concept). Renamed from lift_var. Remove redundant
        check for concepts.
        (lift_variable). New. Accommodates new processing rules for
        variable templates.
        (lift_constraints). Add variable decls to the switch.
        * gcc/cp/pt.c (finish_variable_template): Don't evaluate
        for dependent template arguments.
        (remove_constraints): Remove debugging code.
        * gcc/testsuite/g++.dg/concepts/var-concepts1.C: Separate out
        failing test into equiv2.C.
        * gcc/testsuite/g++.dg/concepts/var-concepts1.C: Update error
        messages.
        * gcc/testsuite/g++.dg/concepts/equiv2.C: New.

2015-03-18  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        Addressing regressions after merge.
        * gcc/cp/parser.c (cp_parser_template_declaration_after_export):
        Revert implementation of concept introductions. It was causing
        scoping issues.
        * gcc/testsuite/g++.dg/concepts/friend1.C: Update test to account
        for apparent fix (?) to lookup rules involving friends.

2015-03-03  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Rewrite to use new constraint model.
        * gcc/cp/call.c (add_function_candidate): Use new constraint
        checking interface.
        (build_new_function_call): Evaluate concepts when selected
        by overload resolution.
        * gcc/cp/class.c (resolve_address_of_overloaded_function):
        Use new constraint interface.
        * gcc/cp/constexpr.c (cxx_eval_constant_expression): Don't 
        try to constexpr evaluate a requires-expression.
        (potential_constant_expression_1): Stop using old
        requires/constraint features.
        gcc/cp/constraint.cc: Much rewriting, reorganization, refactoring
        to support new constraint/requirement terms.
        (lift_function_definition): New. Factor lifting code out of
        lift_call for reuse in evaluate_function_concept.
        (lift_variable_intializer): New. Factor lifting code out of
        lift_var for reuse in evaluate_variable_concept.
        (lift_template_id): Restore checking code for mis-written
        variable concepts.
        (lift_requires_expr): Handle these separately.
        (xform_*_requirement): New. Transform requires-expressions
        into constraints.
        (get/set/remove_constraints, decl_constraints): Move to
        pt.c to allow for garbage collection.
        (processing_constraint): Kill this global.
        (diagnose_*): Update diagnostics to use the new constraint
        interface.
        * gcc/cp/cp-objcp-common.c (cp_common_init_ts): Remove typing
        of old nodes.
        * gcc/cp/cp-tree.def: Add new nodes for requirements and
        constraints. Remove previous constraint/req nodes.
        gcc/cp/cp-tree.h (COMPOUND_REQ_NOEXCEPT_P): New.
        (ICONV_CONSTR_EXPR, ICONV_CONSTR_TYPE): Fix operands.
        (constraint_p, make_predicate_constraint_p, valid_constraints_p): New.
        (misc): Remove unused declarations.
        gcc/cp/cxx-pretty-print.c: Reorganize/rewrite for new constraint
        model.
        (primary_expression, expression): Remove unused nodes, add options 
        for constraints
        gcc/cp/cxx-pretty-print.h: Declare new functions for pretty
        printing.
        gcc/cp/decl.c (duplicate_decls): Only reclaim when flag_concepts
        is on.
        (grokfndecl): Associate predicate constraints.
        gcc/cp/decl2.c (mark_used): Don't instantiate concepts.
        gcc/cp/error.c (dump_expr): Handle new constraints.
        gcc/cp/method.c (implicitly_declare_fn): Use new constraint
        interface.
        gcc/cp/parser.c (make_call_declarator): Pass a requires-clause for
        call declarators.
        (cp_parser_type_name): Take a flag to indicate the presence of
        a pre-parsed 'typename'.
        (cp_parser_requires_expression): Move sentinel into function.
        (cp_parser_type_requirement): Parse type requirements in accordance
        with Concepts TS.
        (cp_parser_compound_requirement): Parse compound requirements in
        accordance with Concepts TS. Remove constexpr requirements.
        (cp_parser_template_declaration_after_export): Associate
        predicate constraints.
        gcc/cp/pt.c (get_template_for_ordering): New. Extract a template
        decl from a list of candidates.
        (lookup_template_class_1): Use new constraint interface.
        (tsubst_pack_conjunction): Build an expression, not constraints.
        (tsubst_decl): Only associate constraints when substituting
        through members.
        (tsubst): Kill subst rules for old nodes.
        (most_specialized_partial_spec): Save candidates correctly
        in the presence of constraints.
        (always_instantiate_p): Never always instantiate a concept.
        (type_dependent_expression_p): Requires expressions have type bool.
        (decl_constraints): Moved from constraint.cc, use hash_table
        instead of hash_map.
        gcc/cp/semantics.c (finish_call_expr): Remove constraints from
        functions, not overload sets.
        (finish_template_variable): Evaluate variable concepts by
        determining satisfaction.
        gcc/cp/typeck.c (cp_build_function_call_vec): Use new concept 
        interface.
        gcc/cp/testsuite/g++.dg/concepts/*: Update tests to match syntax,
        diagnostics.
        gcc/cp/testsuite/g++.dg/concepts/req1.C: Test requires-expression
        with no parens.

2015-02-25  Braden Obrzut  <admin@maniacsvault.net>

        * gcc/cp/constraint.cc (lift_operands): New.
        (lift_call): Lift operands on function calls and don't use
        tsubst_constraint_expr.
        (lift_var): Don't use tsubst_constraint_expr.
        (lift_constraints): Use the returned number of operands for most nodes
        and also lift from TREE_LISTs.

2015-02-17  Braden Obrzut  <admin@maniacsvault.net>

        * gcc/cp/constraint.cc (lift_call): Converted from normalize_call.
        (lift_var): Converted from normalize_var.
        (lift_template_id): Converted from normalize_template_id.
        (lift_constraints): Implemented.

2015-02-16  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/cp-tree.h: (EXPR_CONSTR_EXPR, TYPE_CONSTR_TYPE): Fix 
        typos in macro names.
        * gcc/cp/constraint.cc: (check_constraint*): New. Rewrite the
        constraint checking implementation so that it matches the
        wording and rules in n4377.

2015-02-10  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/logic.cc: Rewrite to use new constraint model and
        update formatting.
        * gcc/cp/constraint.cc: Documentation and organization.

2015-02-10  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/cp-tree.h (is_constraint): Make static.

2015-02-09  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Rewrite normalization in terms of constraints.
        * gcc/cp/cp-tree.h (is_constraint): New.
        * gcc/cp/constraint.cc (normalize_*): Rewrite the previous normalization
        model so that it conforms with the specification. Normalization applies
        to constraints. Transformation of expressions into constraints now
        happens in two phases: lifting concept definitions, and the actual
        transformation.
        (tranform_expression, xform_*): New. Define transformation of 
        expressions into constraints.
        (lift_constraints): New. Stubbed out inlining function.

2015-02-09  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Start refactoring constraints to match the specification.
        * gcc/cp/cp-tree.def: Add new TREECODEs for constraints.
        * gcc/cp/cp-tree.h: Add accessor macros for constraint operands.

2015-02-05  Braden Obrzut  <admin@maniacsvault.net>

        * gcc/cp/constexpr.c (potential_constant_expression_1): Readded missing
        cases from previous merge from trunk.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_trait_expression): Restored
        CPTK_IS_CONVERTIBLE_TO for the time being since the constraint code
        relies on it.
        * gcc/cp/semantics.c (finish_trait_expr): Likewise.
        * gcc/testsuite/g++.dg/concepts/req9.C: New test.

2015-02-03  Braden Obrzut  <admin@maniacsvault.net>

        * gcc/cp/class.c (build_clone): Clone constraints.
        * gcc/cp/constraint.cc (normalize_atom): Update diagnostic.
        (normalize_constraints): Return error_mark_node if normalization fails.
        (get_constraints): Access constraints through hash map.
        (set_constraints): Set constraints through hash map.
        (remove_constraints): Access constraints through hash map.
        (associate_classtype_constraints): New.
        (init_leading_requirements): Removed.
        (init_trailing_requirements): Removed.
        (update_leadng_requirements): Removed.
        (update_trailing_requirements): Removed.
        (save_leading_constraints): Removed.
        (save_trailing_constraints): Removed.
        (finish_template_constraints): Removed.
        (build_constraints): New. Builds CONSTRAINT_INFO from requirements.
        (finish_concept_introduction): Check generated parameters for errors.
        (tsubst_constraint_info): Update implementation.
        (equivalent_constraints): Check input types.
        (subsumes_constraints): Update implementation.
        (at_least_as_constrained): New. Check if a decl's constraints subsumes
        another.
        (diagnose_constraints): Temporarily simplify diagnostics.
        * gcc/cp/cp-tree.h (tree_constraint_info): Refactor the way constraints
        are stored.
        (CI_TEMPLATE_REQS): Renamed from CI_LEADING_REQS.
        (CI_DECLARATOR_REQS): Renamed from CI_TRAILING_REQS.
        (CI_ASSOCIATED_CONSTRAINTS): New.
        (CI_NORMALIZED_CONSTRAINTS): New.
        (CI_ASSOCIATED_REQS): Removed.
        (saved_scope): Save template requirements.
        (current_template_reqs): Removed.
        (lang_decl_min): Replace requires_clause (trailing requirements) with
        more generic constraint_info.
        * gcc/cp/cxx-pretty-print.c (cxx_pretty_printer::declarator): Print
        requires clause.
        (pp_cxx_function_definition): Moved requires clause printing to above.
        (pp_cxx_init_declarator): Likewise.
        (pp_cxx_template_declaration): Update implementation to get
        requirements from CONSTRAINT_INFO.
        * gcc/cp/decl.c (duplicate_decls): Remove constraints before reclaiming
        memory.
        (is_class_template_or_specialization): New.
        (get_leading_constraints): Removed.
        (adjust_fn_constraints): Removed.
        (grokfndecl): Update implementation to other changes.
        (get_trailing_requires_clause): New.
        (grokdeclarator): Pass trailing requires clause to grokfndecl.
        (xref_tag_1): Check overload constraints.
        * gcc/cp/error.c (dump_template_decl): Print requires clause.
        (dump_function_decl): Update implementation for accessing requirements.
        * gcc/cp/logic.cc (subsumes_constraints_nonnull): Update
        CI_ASSOCIATED_REQS usage.
        * gcc/cp/method.c (implicitly_declare_fn): Copy constraints of
        inherited constructors.
        * gcc/cp/parser.c (cp_parser_lambda_expression): Remove now unneeded
        template requirements saving.
        (cp_parser_type_parameter): Likewise.
        (cp_parser_template_argument_list): Unwrap template_template_parms when
        produced by short hand notation with function concepts.
        (cp_parser_alias_declaration): Attach constraints to aliases.
        (cp_manage_requirements): Removed.
        (cp_parser_trailing_requirements_clause): Renamed from
        cp_parser_trailing_requirements.
        (cp_parser_init_declarator): Removed now unneeded requirements saving.
        (cp_parser_basic_declarator): Separated from cp_parser_declarator.
        (cp_parser_declarator): Parses trailing requires clause if
        cp_parser_basic_declarator succeeds.
        (cp_parser_class_specifier_1): Associate constaints with type.
        (cp_parser_member_declaration): Remove unneeded template requirement
        saving.
        (cp_parser_template_declaration_after_export): Likewise.
        (cp_parser_single_declaration): Associate constraints.
        (cp_parser_late_parsing_for_member): Remove unneeded template
        requirement saving.
        (synthesize_implicit_template_parm): Likewise.
        * gcc/cp/pt.c (maybe_new_partial_specialization): Update
        implementation.
        (process_template_parm): Removed unneeded template requirement saving.
        (build_template_decl): Handle constraints.
        (process_partial_specialization): Update constraint access and check
        that specialization is more specialized.
        (push_template_decl_real): Update constraint access.
        (add_inherited_template_parms): Removed constraint handling.
        (tsubst_pack_conjuction): Update implemenation.
        (tsubst_decl): Changed constraint propagation.
        (more_specialized_fn): Update constraint access.
        (most_specialized_partial_spec): Update constraint access.
        * gcc/cp/ptree.c (cxx_print_xnode): Update constraint access.
        * gcc/cp/semantics.c (finish_call_expr): Remove constraints.
        (finish_template_template_parm): Update constraint access.
        * gcc/testsuite/g++.dg/concepts/alias4.C: Mark xfail.
        * gcc/testsuite/g++.dg/concepts/class.C: Check for escape hatch.
        * gcc/testsuite/g++.dg/concepts/class6.C: Added diagnostic.
        * gcc/testsuite/g++.dg/concepts/inherit-ctor1.C: Improved test case.
        * gcc/testsuite/g++.dg/concepts/inherit-ctor2.C: Updated diagnostic.
        * gcc/testsuite/g++.dg/concepts/inherit-ctor4.C: Updated diagnostic.
        * gcc/testsuite/g++.dg/concepts/intro4.C: Updated diagnostics.
        * gcc/testsuite/g++.dg/concepts/req4.C: Updated diagnostic.
        * gcc/testsuite/g++.dg/concepts/req5.C: Updated diagnostic.

2014-12-29  Jason Merrill  <jason@redhat.com>

        * gcc/cp/pt.c (type_dependent_expression_p): Remove obsolete use of
        PLACEHOLDER_EXPR.
        (convert_template_argument): Likewise.

2014-11-15  Braden Obrzut  <admin@maniacsvault.net>

        * gcc/cp/constraint.cc (resolve_constraint_check): Move definition
        check to grokfndecl.
        (normalize_template_id): Use expression location if available when
        informing about missing parentheses.
        (build_requires_expr): Added comment.
        (diagnose_var): Clarified comment.
        * gcc/cp/decl.c (check_concept_refinement): Remove outdated comment
        regarding variable concepts.
        (grokfndecl): Ensure that all concept declarations are definitions.
        (grokdeclarator): Remove outdated comment regarding variable concepts.
        * gcc/cp/parser.c (cp_parser_introduction_list): Use vec for temporary
        list instead of a TREE_LIST.
        (get_id_declarator): Renamed from cp_get_id_declarator.
        (get_unqualified_id): Renamed from cp_get_identifier.
        (is_constrained_parameter): Renamed from cp_is_constrained_parameter.
        (cp_parser_check_constrained_type_parm): Renamed from
        cp_check_constrained_type_parm.
        (cp_parser_constrained_type_template_parm): Renamed from
        cp_constrained_type_template_parm.
        (cp_parser_constrained_template_template_parm): Renamed from
        cp_constrained_template_template_parm.
        (constrained_non_type_template_parm): Renamed from
        cp_constrained_non_type_tmeplate_parm.
        (finish_constrained_parameter): Renamed from
        cp_finish_constrained_parameter.
        (maybe_type_parameter): Renamed from cp_maybe_type_parameter.
        (declares_type_parameter): Renamed from cp_declares_type_parameter.
        (declares_type_template_parameter): Renamed from
        cp_declares_type_template_parameter.
        (declares_template_template_parameter): Renamed from
        cp_declares_template_template_parameter.
        (cp_parser_type_parameter): Call
        cp_parser_default_type_template_argument and
        cp_parser_default_template_template_argument which were already
        factored out from this function.
        (cp_maybe_constrained_type_specifier): Use the new INTRODUCED_PARM_DECL
        instead of PLACEHOLDER_EXPR.
        (cp_parser_requires_expr_scope): Remove old comment and change
        destructor to use pop_bindings_and_leave_scope.
        (cp_parser_requires_expression): Remove old comment.
        (get_concept_from_constraint): Remove old comment.
        * gcc/testsuite/g++.dg/concepts/decl-diagnose.C: Changed expected
        errors now that missing concept definitions are diagnosed earlier.

2014-11-11  Jason Merrill  <jason@redhat.com>

        * gcc/cp/call.c (add_function_candidate): Move constraint check after
        arity check.

        * gcc/cp/class.c (get_member_fn_template)
        (are_constrained_member_overloads): Remove.
        (add_method): Call equivalently_constrained directly.

2014-11-03  Jason Merrill  <jason@redhat.com>

        * gcc/cp/parser.c (cp_parser_nonclass_name): Fix merge error.

2014-10-20  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fixing user-reported issues and regressions
        * gcc/cp/parser.c (cp_parser_template_declaration_after_exp):
        Only pop access checks on failed parsing.
        * gcc/cp/pt.c (type_dependent_expr_p): Always treat a 
        requires-expr as if dependently typed. Otherwise, we try to
        evaluate these expressions when they have dependent types.
        * gcc/cp/constriant.cc (normalize_stmt_list): Remove unused
        function.
        (normalize_call): Don't fold constraints during normalization.
        * gcc/testsuite/g++.dg/concepts/decl-diagnose.C: Update diagnostics.

2014-10-20  Andrew Sutton  <andrew.n.sutton@gmail.com>

                                Fix another introduction regression.
                                * gcc/cp/parser.c (cp_parser_template_declaration_after_exp):
                                Only pop access checks on failed parsing.

2014-10-13  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix regression related to concept introductions.
        * gcc/cp/parser.c (cp_parser_template_declaration_after_exp):
        Pop deferred access checks afer parsing the introduction.

2014-10-13  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix bug related to cleanup expressions in concept definitions.
        * gcc/cp/constraint.cc (check_function_concept): See through
        cleanup handlers when checking the body of a function.
        (normalize_cast): Removed. Handled in a default case.
        (normalize_cleanup_point): New. Normalize the expression without
        the cleanup handler.

2014-09-25  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Explicitly disallow function concepts with deduced return types.
        * gcc/cp/constraint.cc (check_function_concept): Remove check
        for deduced return type.
        * gcc/cp/decl.c (check_concept_fn): Explicitly check for
        deduced return type.
        * gcc/testsuite/g++.dg/concepts/fn-concept2.C: New.

2014-09-24  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Check requirements on function concept definitions.
        * gcc/cp/decl.c (finish_function): Check properties of a function
        concept definition.
        * gcc/cp/constraint.cc (check_function_concept): New. Check
        for deduced return type and multiple statements.
        (normalize_misc): Don't normalize multiple statements.
        (normalize_stmt_list): Removed.
        * gcc/cp/cp-tree.h (check_function_concept): New.
        * gcc/testsuite/g++.dg/concepts/fn-concept1.C: New.

2014-09-04  Braden Obrzut  <admin@maniacsvault.net>

        Implement concept introductions.
        * gcc/cp/constraint.cc (deduce_concept_introduction): New.
        (build_concept_check): Allow arg to be NULL to skip placeholder.
        (process_introduction_parm): New.
        (finish_concept_introduction): New.
        * gcc/cp/cp-objcp-common.c (cp_common_init_ts): Mark introduced parm.
        * gcc/cp/cp-tree.def: New INTRODUCED_PARM_DECL.
        * gcc/cp/parser.c (cp_parser_declaration): Tentatively parse for
        concept introduction.
        (cp_parser_introduction_list): New.
        (cp_parser_member_declaration): Tentatively parse for concept
        introduction.
        (cp_parser_template_introduction): New.
        (cp_parser_template_declaration_after_export): Parse concept
        introductions.
        * gcc/cp/pt.c (convert_template_argument): Treat INTRODUCED_PARM_DECL
        as a placeholder.
        (coerce_template_parms): If INTRODUCED_PARM_DECL represents a pack then
        match the entire parameter pack of the template.
        (type_dependent_expression_p): Treat INTRODUCED_PARM_DECL as a
        placeholder.
        * gcc/testsuite/g++.dg/concepts/introduction1.C: New.
        * gcc/testsuite/g++.dg/concepts/introduction2.C: New.
        * gcc/testsuite/g++.dg/concepts/introduction3.C: New.
        * gcc/testsuite/g++.dg/concepts/introduction4.C: New.
        * gcc/testsuite/g++.dg/concepts/introduction5.C: New.

2014-09-01  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fixing normalization in the presence of constructor calls.
        * gcc/cp/constraint.cc (normalize_misc): Handle constructor
        expressions.
        * gcc/testsuite/g++.dg/concepts/req7.C: New.

2014-08-29  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fixing partial-template-id bug.
        * gcc/cp/parser.c (cp_parser_type_name): If the returned type-decl
        is actually a shorthand declaration, don't simulate an error.
        * gcc/testsuite/g++.dg/concepts/template-parm10.C: New.

2014-08-15  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Add tests for constrained friends.
        * gcc/testsuite/g++.dg/concepts/friend1.C: New.
        * gcc/testsuite/g++.dg/concepts/friend2.C: New.

2014-08-15  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/decl.c (is_concept_var): Coding style fix.

2014-08-15  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fixing regression in scoping rules for templates.
        * gcc/cp/semantics.c (fixup_tmeplate_type): Lift check to
        finish_template_type.
        (finish_template_type): Only do this when concepts are enabled,
        and also when the class is actually a template. For non-dependent
        types there are no actions to be taken.

2014-08-15  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Additional declaration restrictions on variable concepts.
        * gcc/cp/decl.c (is_concept_var): New.
        (cp_finish_decl): Check for uninitialized variable
        concepts.
        (grokvardecl): Don't set the concept flag for non-template variables.
        * g++.dg/concepts/decl-diagnose.C: Add tests.

2014-08-19  Ville Voutilainen  <ville.voutilainen@gmail.com>

        Ban static member function concepts.
        * gcc/cp/decl.c (grokdeclarator): Diagnose static member function 
        concepts.
        * g++.dg/concepts/decl-diagnose.C: Adjust.
        * g++.dg/concepts/mem-concept-err.C: Adjust.
        * g++.dg/concepts/mem-concept.C: Adjust.

2014-08-15  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fixes to variable concept implementation.
        * gcc/cp/cp-tree.h (variable_concept_p): New.
        * gcc/cp/parser.c (cp_parser_nonclass_name): Check for concepts,
        not just templates.
        * gcc/cp/decl.c (grokvardecl): Label concepts as concepts.
        * gcc/cp/constraint.cc (check_call): New.
        (normalize_call): Ensure that calls are probably to functions.
        (normalize_template_id): Update diagnostics.
        (finish_template_constraints): Mark assumptions as an error if
        constraint normalization fails. This was causing normalization
        to be run twice during the construction of a single declaration.
        * gcc/testsuite/g++.dg/concepts: Update tests.

2014-08-14  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix regression.
        * gcc/cp/pt.c (value_dependent_expression_p): Don't assume
        that all nodes have operands.

2014-08-14  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Implement normalization checks.
        * gcc/cp/constraint.cc (normalize_expr): Delegate cast and
        atomic nodes to a dedicated function.
        (check_logical): Check that an && or || does not resolve to a
        user-defined function.
        (normalize_logical): Check operators and save the locaiton of
        the new expression.
        (normalize_call, normalize_var): Remove spurios error messages.
        (normalize_cast): New, delegates to normalize atom.
        (normalize_atom): Check that instantiated expressions can be
        converted to bool
        (tsubst_constraint_info): Re-normalize the associated constraints
        to check for post-substitution restrictions.
        * gcc/cp/cp-tree.h (xvalue_result_type): Add to header.

2014-08-14  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/testsuite/g++.dg/concepts: Renamed ttp* to template-parm*,
        and fixed them.

2014-08-13  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/class.c (resolve_address_of_overloaded_function): Check
        constraints.
        * gcc/cp/decl.c (grokfndecl): For now, disallow constrained
        non-template functions.
        * gcc/testsuite/g++.dg/concepts: New tests.

2014-08-13  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/parser.c (get_id_declarator, get_identifier): New helper
        functions.s
        (cp_check_constrained_type_parm): Don't fail on null declarators.
        (cp_finish_constrained_parameter): Remove redundant processing for
        checking declarations.
        (cp_maybe_type_parameter, cp_declares_type_parameter, 
        cp_declares_type_template_parameter, 
        cp_declares_template_template_parameter): New helper functions for
        determining when a parameter declaration is actually a constrained
        template parameter.
        (cp_parser_default_type_template_argument, 
        cp_parser_default_template_template_argument): Parsing support
        for argument types of default arguments.
        (cp_parser_template_parameter): Finish constrained parameters
        after all variadic and default arg checks.
        (cp_parser_parameter_declaration): Parse default arguments
        differently if the parameter actually declares a type parameter.
        * gcc/testsuite/g++.dg/concepts: New tests.

2014-08-13  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/testsuite/g++.dg/concepts/explicit-spec6.C: New test.

2014-08-13  Andrew Sutton  <andrew.n.sutton@gmail.com>

        Fix regression in bootstrap.
        * gcc/cp/call.c (get_temploid): Removed. No longer called.
        (joust): Remove unused variable declarations.

2014-08-13  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        Implement deduction-based explicit instantiation and specialization.
        * gcc/cp/call.c (joust): Allow all non-templates to be ordered by
        constraints.
        * gcc/cp/pt.c (get_class_bindings): Remove superfluous parameter and
        move constraint check into most_specialized_class.
        (most_constrained_function): Order functions with the same signatures
        by their constraints.
        (determine_specialization): Candidates must satisfy constraints. Also,
        order non-template candidates by constraints. Improve diagnostics
        for instances where candidates are rejected.
        (more_specialized_inst): New. Compare function templates.
        (most_specialized_instantiation): Refactor to use 
        more_specialized_inst and order by constraints.
        (most_specialized_class): Candidates must satisfy constraints.
        * gcc/cp/decl.c (various) Cosmetic fixes.
        (adjust_fn_constraints): Rewrite so that class template constraints
        are not imposed on member function declarations.
        * gcc/testsuite/g++.dg/concepts: New tests.

2014-08-13  Braden Obrzut <admin@maniacsvault.net>

        * gcc/cp/constraint.cc (deduce_constrained_parameter): Deduce concept
        from variable concept template-id expressions.
        (normalize_var): New.
        (normalize_template_id): Identify variable concepts.
        (build_concept_check): Handle variable concepts.
        (finish_shorthand_requirement): Handle variable concepts.
        (diagnose_var): New.
        (diagnose_node): Identify variable concepts.
        * gcc/cp/decl.c (grokvardecl): Pass concept flag through to
        check_explicit_specialization.
        (grokdeclarator): Allow variable concepts and pass concept flag through
        grokvardecl.
        * gcc/cp/parser.c (cp_is_constrained_parameter): Accept variable
        concepts.
        (cp_parser_nonclass_name): Accept variable concepts.
        (get_concept_from_constraint): Handle variable concepts.
        * gcc/cp/pt.c (tsubst_copy_and_build): Lookup variable templates.
        (value_dependent_expression_p): Check requires expressions for value
        dependence.
        * gcc/cp/semantics.c (finish_call_expr): Don't instantiate variable
        templates if processing a template declaration.
        * gcc/testsuite/g++.dg/concepts/decl-diagnose.C: Change expected error
        as variable concepts are now handled.
        * gcc/testsuite/g++.dg/concepts/var-concepts1.C: New test.
        * gcc/testsuite/g++.dg/concepts/var-concepts2.C: New test.

2014-08-11  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/pt.c (tsubst): Don't short circuit substitution into
        types when processing constraints. Also, avoid asserting when
        substituting into template parameters.
        * gcc/cp/constraint.c (tsubst_constraint_expr): Indicate that
        constraint processing is happening.
        (tsubst_constraint_info): Just substitute directly into the
        normalized constraints instead of re-normalizing.
        (diagnose_constraints): Adjust template arguments when
        diagnosing template constraint failures.
        * gcc/cp/logic.cc (decompose_assumptions): Handle null assumptions.

2014-08-08  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/logic.cc (subsumes_constraints_nonnull): Don't re-normalize
        constraints, it's already been done.
        * gcc/cp/cp-tree.h (*_requirement[s]): Renamed to *_constraint[s] to
        reflect wording in specification. Removed reduce_requirements.
        * gcc/cp/pt.c (process_template_parm, tsubst_pack_conjunction): Update 
        from renaming.
        (fn_type_unification): Remove constraint check.
        * gcc/cp/parser.c (cp_parser_type_parameter, 
        cp_parser_trailing_requirements, 
        cp_parser_template_declaration_after_export,
        synthesize_implicit_template_parm): Update from renaming.
        * gcc/cp/constraint.cc: Renamed a lot of functions to reflect wording
        in specification.
        (finish_template_constraints): Normalize associated constraints.
        (tsubst_constraint_expr): Renamed from instantiate_requirements.
        Normalize associated constraints.
        (check_satisfied): Return true if the arguments refer to template
        parameters.
        (all_constraints_satisfied, any_conjunctions_satisfied,
        check_requirements): No longer needed.
        (check_diagnostic_constraints): Just normalize the expression, don't
        decompose it.

2014-08-06  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/testsuite/g++.dg/concepts/concepts.exp: Add missing argument
        to g++-dg-runtest.

2014-08-06  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/constraints.c (tsubst_requires_body, instantiate_requirements):
        Lift the unevaluated operand guard to the entire constraint expression.
        (check_satisfied, all_constraints_satisfied, 
        any_conjunctions_satisfied): Rewrite constraint checking to use
        atomic constraints. Prevents instantiation of concepts.
        (check_diagnostic_constraints): Recursively decompose and check
        constraints for fine-grain diagnostics.
        (diagnose_*): Use new constraint checking function.
        

2014-07-30  Braden Obrzut  <admin@maniacsvault.net>
        
        * gcc/cp/parser.c (cp_parser_trailing_requirements): Handle requires
        keyword manually so that we can push function parameters back into
        scope.
        * gcc/cp/decl.c (push_function_parms): New. Recovers and reopens
        function parameter scope from declarator.
        * gcc/testsuite/g++.dg/concepts/req*.C: New tests.

2014-07-30  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/testsuite/g++.dg/concepts/test.C: Removed.

2014-07-28  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/cp-tree.h (more_constraints): Remove
        (subsumes_constraints): Renamed from more_constraints
        (more_constrained): Repurposed
        * gcc/cp/call-c (template_decl_for_candidates): Rename to get_temploid,
        only get template info for member functions of a class template
        specialization.
        (joust): Handle member functions of class template specializations
        separately from function templates. This matches the new wording in
        the TS.
        * gcc/cp/logic.cc (match_terms): Make inline.
        (subsumes_constraints): Rename to subsumes_constraints_nonnull.
        * gcc/cp/pt.c (is_compatible_template_arg): Use subsumes.
        (more_specialized_fn): Use usubsumes_constraints.
        (more_specialized_class): Use more_constrained.
        * gcc/cp/constraint.cc (more_constraints): Removed.
        (more_constrained): New.

2014-07-11  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/typeck.c (cp_build_function_call_vec): Emit diagnostic
        at the input location.
        * gcc/cp/error.c (dump_template_decl): Constraints are never invalid
        in this way. Also fixes brace warning.

2014-07-11  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/tree.c (cp_tree_equal): compare constraint infos by
        their associated constraints (patch by Braden Obrzut).
        * gcc/cp/logic.c (decompose_assumptions): Don't decompose errors.
        (subsumes_constraints): Update to use new macros.
        * gcc/cp/cp-tree.h (tree_constraint_info): Rewrite constraints
        to cache leading, trailing, and associated requirements.
        (CI_SPELLING, CI_REQUIREMENTS): Remove
        (CL_LEADING_REQS, CI_TRAILING_REQS, CI_ASSOCIATED_REQS): New
        accessors for constraint info field.
        (save_leading_requirements, save_trailing_requirements,
        valid_template_requirements_p): New.
        (make_constraints): Removed.
        (instantiate_requirements): Add flag to substitute in either
        dependent/non-dependent mode.
        (tsubst_constraint_info): New.
        * gcc/cp/cxx-pretty-print.h (pp_cxx_requires_clause): New.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_init_declarator): Remove.
        (pp_cxx_function_definition): Print trailing constraints if they
        exist.
        (pp_cxx_init_declarator): New. Print trailing requirements.
        (pp_cxx_template_declaration): Print leading requirements.
        (pp_cxx_requires_clause): New.
        * gcc/cp/pt.c (build_template_decl): Ensure completion of constraints
        when associating them with the template.
        (add_inherited_template_parms): Update to new constraint mechanisms.
        (redeclare_class_template): Update to new constraint mechanisms.
        (tsubst_decl): Update to new constraint mechanism.
        * gcc/cp/parser.c (cp_parser_lambda_expression): Save off constraints
        in a generic lambda.
        (cp_check_constrained_type_parm): Save leading requirements instead
        of finishing them.
        (cp_parser_trailing_requirements): Simplify by just saving the trailing
        requirements.
        (cp_parser_init_declarator): Save off constraints before parsing the
        declarator.
        (cp_parser_member_declaration): Save off requirements before parsing
        the declarator.
        (cp_parser_requires_clause): Defer constexpr check until as late as
        possible.
        (cp_parser_template_declaration_after_export): Save leading requirements
        instead of finishing them.
        (synthesize_implicit_template_parm): Save leading requirements when
        processing a constrained-type-specifier.
        * gcc/cp/class.c (get_member_fn_template): Update to use new constraint
        mechanism.
        * gcc/cp/call.c (constraint_failure): Renamed from
        template_constraint_failure. Produce reasons for non-template functions.
        (is_constrainable_non_template_fn): Removed.
        (add_function_candidate): Use new constraint association framework.
        * gcc/cp/ptree.c (cxx_print_xnode): Dump leading, trailing requirements.
        * gcc/cp/error.c (dumpl_template_decl): Print a leading requires-clause.
        (dump_function_decl): Print a trailing requires-clause.
        * gcc/cp/semantics.c (finish_template_template_parm): Finish
        template constraints before associating them.
        * gcc/cp/constraint.cc (reduce_call): Don't fold constants when
        substituting.
        (reduce_template_id): Replace EXPR_LOCATION in diagnostics. Return
        error_mark_node instead of corrected call expression.
        (reduce_requirements): Don't normalize a null expression.
        (make_constraints): Removed.
        (get_constraints): Updated.
        (set_constraint): Updated.
        (get_shorthand_requirements): Use the appropriate macro.
        (build_constraint_info, init_leading_requirements, 
        init_trailing_requirements, update_leadng_requirements,
        update_trailing_requirements, save_leading_requirements,
        save_trailing_requirements): New.
        (finish_template_requirements): Analyze and decompose constraints.
        (valid_template_requirements_p): New.
        (instantiate_requirements): New flag.
        (tsubst_constraint_info): New.
        (check_requirements): Update.
        (check_constraints): Add another round of instantiation to ensure
        that all non-constexpr exprs are folded out of the expression.
        (check_constraints): Update.
        (equivalent_constraints): Redefine constraint equivalence in terms
        of tokens (patch by Braden Obrzut).
        (diagnose_trait, diagnose_check, diagnose_requires, 
        diagnose_constraints): Update.
        * gcc/cp/decl2.c (check_classfn): Update constraint mechanisms.
        * gcc/cp/decl.c (decls_match): Update to use new constraints.
        (duplicate_decls): members match if they have equivalent constraints.
        (get_leading_template_requirements): New.
        (adjust_out_of_class_fn_requirements): New.
        (grokfndecl): Associate requirements with a function declaration.
        * gcc/testsuite/g++.dg/concepts/*: New tests.

2014-06-28  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/c-family/c.opt (flag_concepts): Don't enable by default.
        * gcc/c-family/c-opts.c (set_std_cxx1z): Enable concepts if
        -std=cxx1z is selected.
        * gcc/c-family/c-format.c (gcc_cxxdia): Add "Z" as format specifier.
        * gcc/cp/c-common.c (cxx_dialect): Make -std=c++98 the default
        language again.
        * gcc/cp/lex.c (cxx_init): Don't set flag_concepts explicitly.
        * gcc/testsuite/g++.dg/concepts/*.C: Update build flags.

2014-06-28  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/cp-tree.h (DECL_CONSTRAINTS): Remove this macro; use
        get_constraints instead.
        (set_constraints): new.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_template_declaration): Use
        get_constraints.
        * gcc/cp/pt.c (get_specialization_constraints): Use get_constraints.
        (build_template_decl): Use get_constraints.
        (process_partial_specialization): Use get_constraints.
        (add_inherited_template_parms): Use get_constraints.
        (redeclare_class_template): Use get_constraints.
        (is_compatible_template_arg): Use get_constraints.
        (tsubst_friend_class): Use get_constraints.
        (tsubst_decl): Uset get_constraints.
        * gcc/cp/semantics.c (finish_template_template_parm): Use
        get_constraints.
        (fixup_template_type): Use get_constraints.
        * gcc/cp/constraint.cc (constraints): New global association
        of declarations to constraints.
        (get_constraints): Return the associated constraints from the
        hash table.
        (set_constraints): New. Associate constraints with a declaration.
        (check_template_constraints): Use get_constraints.
        (equivalently_constrained): Use get_constraints.
        (more_constrained): Use get_constraints.
        (diagnose_constraints): Use get_constraints.
        * gcc/testsuite/g++.dg/concepts/partial-spec.C: New.

2014-06-25  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parser.c (cp_parser_requires_clause): Don't fold expressions
        when parsing a requires-clause.
        * gcc/cp/constraint.cc (reduce_requirements): Don't fold
        expressions during constraint normalization.

2014-06-24  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parser.c (cp_maybe_constrained_type_specifier): Defer
        handling the BASELINK check until concept-resolution in order to
        allow member conceps.
        (cp_parser_nonclass_name): Also Check for concept-names when the
        lookup finds a BASELINk.
        * gcc/cp/constraint.cc: (resolve_constraint_check) If the call
        target is a base-link, resolve against its overload set.
        (build_concept_check): Update comments and variable names to
        reflect actual processing.
        * gcc/testuite/g++.dg/concepts/mem-concept.C: New test.
        * gcc/testuite/g++.dg/concepts/mem-concept-err.C: New test.

2014-06-24  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/error.c (dump_expr): Pretty print placeholder to improve
        debug output.

2014-06-17  Braden Obrzut  <admin@maniacsvault.net>
        
        * gcc/cp/parser.c (cp_maybe_constrained_type_specifier): If getting
        a baselink, use the referred-to function/overload declarations rather
        than asserting.

2014-06-12  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/constraint.cc (deduce_constrained_parameter): Refactor
        common deduction framework into separate function.
        (build_call_check): New.
        (build_concept_check): Take additional arguments to support the
        creation of constrained-type-specifiers from partial-concept-ids.
        (build_constrained_parameter): Take arguments from a partial-concept-id.
        * gcc/cp/cp-tree.h (build_concept_check, biuld_constrained_parameter):
        Take a template argument list, defaulting to NULL_TREE.
        * gcc/cp/parser.c (cp_parser_template_id): Check to see if a 
        template-id is a concept check.
        (cp_check_type_concept): Reorder arguments
        (cp_parser_allows_constrained_type_specifier): New. Check contexts
        where a constrained-type-specifier is allowed.
        (cp_maybe_constrained_type_specifier): New. Refactored common rules
        for concept name checks.
        (cp_maybe_partial_concept_id): New. Check for 
        constrained-type-specifiers.
        * gcc/testuite/g++.dg/concepts/partial.C: New tests.
        * gcc/testuite/g++.dg/concepts/partial-err.C: New tests.
        * gcc/testuite/g++.dg/concepts/concepts.exp: Add missing test driver.

2014-06-12  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parser.c (cp_check_type_concept): New.
        (cp_check_concept_name): Remove redundant condition from check.
        Diagnose misuse of non-type concepts in constrained type specifiers.
        * gcc/testuite/g++.dg/concepts/generic-fn.C: Add tests for
        non-simple constrained-type-specifiers and nested-name-specifiers
        in concept names.
        * gcc/testuite/g++.dg/concepts/generic-fn-err.C: New tests for
        diagnosing ill-formed programs.

2014-06-11  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/cp-tree.h (build_constrained_parameter): Renamed fro
        describe_tempalte_parm.
        * gcc/cp/parser.c (cp_check_constrained_type_parm): New. Prevent
        declaration of cv-qualifed or non-id types.
        (cp_constrained_type_template_parm): Renamed, check for invalid 
        specifiers.
        (cp_constrained_template_template_parm): Renamed, check for invalid
        specifiers.
        (cp_constrained_non_type_tmeplate_parm): Renamed.
        (cp_finish_constrained-parameter): Support checking of decarlarations.
        (cp_check_concept_name): Renamed. Add initial support for auto
        and constrained-type-specifiers in compound requirements.
        (cp_parser_nonclass_name): Only check for concept names if -fconcepts
        is on.
        (cp_manage_requirements): New RAII guard for managinging the
        current_template_reqs variable during declaration parsing.
        (cp_paresr_trailing_requirements): Refactored common parsing
        requirements from cp_parser_init_declarator and 
        cp_parser_member_declarator. Take terse constraints from implicit
        parameter declarations.
        (cp_parser_init_declarator): Cleanup, refactor requirement logic.
        (cp_parser_type_id_1): Allow auto in compound requirements.
        (cp_parser_member_declaration): Cleanup, refactor requirement logic.
        (cp_parser_compound_requirement): Note parsing state for the 
        trailing-type-id so we can get auto and constrained-type-specifiers.
        (cp_parser_function_definition_after_decl): Remove broken constraint
        association.
        * gcc/cp/parser.h (cp_parser): New member.
        * gcc/cp/constraint.cc (finish_validtype_expr): Initial (non-)handling
        of auto in type requirements.
        (finish_concept_name): Moved to cp_check_concept_name.
        * gcc/testuite/g++.dg/concepts/constrained-parm.C: New test.
        * gcc/testuite/g++.dg/concepts/generic-fn.C: New test.


2014-03-10  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/testuite/g++.dg/concepts/fn1.C: New test.
        * gcc/testuite/g++.dg/concepts/fn2.C: New test.

2013-11-012  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parser.c (synthesize_implicit_template_parm): Allow concepts
        to declare implicit template parameters. Only synthesize new parameters
        if the concept name is new.
        (finish_concept_name): Moving into parser.c for the time being. Needs
        to be rewritten to remove duplicate code between parser.c and
        constraint.cc.

2013-11-012  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/pt.c (tsubst_copy): Expand pack expansions as conjunctions.

2013-11-012  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/pt.c (tsubst_pack_conjunction): Don't try to conjoin
        dependent expressions.

2013-11-012  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/semantics.c (fixup_template_type): Compare primary template
        types to specializations using structural types so we don't run into
        canonical type errors with constrained specializations.

2013-11-08  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/pt.c (add_inherited_template_parms): Instantiate requirements
        in a processing template decl context.

2013-11-05  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/semantics.c (fixup_template_type): Add a same-type check
        for specialiations so we don't accidentally match non-dependent
        specializations having a different type.

2013-10-26  Ville Voutilainen  <ville.voutilainen@gmail.com>
        
        * gcc/cp/decl.c (grokdeclarator): Reject concept keyword
        in typedefs, function parameters, data members, non-static
        member functions and variables. Allow static member functions
        to be concepts.

2013-10-30  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/semantics.c (fixup_template_type): Don't emit errors when
        no templates can be found with matching constraints.

2013-10-25  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parsre.c (cp_parser_requires_expression): Gracefully
        fail when parsing a requires expr outside a template.

2013-10-24  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/c-common.c (c_common_r): Remove unused keywords "assume",
        "axiom", and "forall".
        * gcc/cp/c-common.h (rid): Removed unused reserved word ids.

2013-10-24  Edward Smith-Rowland  <3dw4rd@verizon.net>
        
        * gcc/cp/typeck.c (cp_build_function_call_vec): Use unused variable 
        loc.

2013-10-23  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/class.c (get_member_fntemplate): New.
        (are_constrained_member_overloads): Only get a template declaration
        if the member function is, in fact, a template or temploid.
        * gcc/cp/pt.c (check_explicit_specialization): Do not allow
        explicit specializations to be declared 'concept', and do not allow
        an explicit specialization of a concept.
        * gcc/cp/decl.c (grokfndecl): Propagate the concept flag to
        check_explicit_specialization.

2013-10-22  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/c-family/c-common.c (cxx_dialect): Make the default
        language C++11.
        * gcc/cp/constraint.cc (check_constrained_friend): Don't assert
        on error_mark_node.

2013-10-16  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/logic.cc (left_requires), (decompose_left): Add
        decomposition rules for requires expressions.
        (subsumes_requires), (subsumes_prop): Add subsumption rules for
        requires expressions.
        * gcc/cp/constraint.cc (diagnose_trait): Diagnose failed conversion
        requirements.

2013-10-16  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/constraint.cc (finish_concept_name): Allow functions with
        the same name as concepts to resolve as call expressions in the
        usual way.

2013-10-16  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/constraint.cc (conjoin_requiremens): New.
        (resolve_constraint_check): Filter non-concept candidates before
        coercing arguments. Perform deduction in a template-decl processing
        context to prevent errors during diagnosis.
        (finish_concept_name), (finish_shorthand_requirement),
        (get_shorthand_requirements): New.
        * gcc/cp/pt.c (template_parm_to_arg): Make non-static.
        (process_templat_parm): Build shorthand requirements from the
        parameter description.
        (end_templat_parm_list): New.
        (convert_placeholder_argument): New.
        (convert_template_argument): Match placeholder arguments against
        any template parameter.
        (tsubst_pack_conjuction):  New.
        (tsubst_expr): Expand a pack as a conjunction.
        (type_dependent_expression_p): Placeholders are always type
        dependent.
        * gcc/cp/parser.c (cp_is_constrained_parameter), 
        (cp_finish_template_type_parm), (cp_finish_template_template_parm)
        (cp_finish_non_type_template_parm), (cp_finish_constrined_parameter):
        New.
        (cp_parser_template_parameter): Handle constrained parameters.
        (cp_parser_nonclass_name): An identifier naming an overload set
        may declare a constrained parameter.
        (cp_parser_type_parameter), (cp_parser_template_declaration_after_exp): 
        Get shorthand requirements from the tmeplate parameter list.
        * gcc/cp/cp-tree.h (TEMPLATE_PARM_CONSTRAINTS): New.

2013-10-07  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/cp-tree.h (check_constrained_friend): Take requirements as
        an argument.
        * gcc/cp/constraints.cc (check_constrained_friend): Do not diagnose
        errors in unconstrained friend declarations.
        * gcc/cp/parser.cc (cp_parser_member_declaration): Pass current
        requirements to check_constrained_friend.

2013-10-07  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parser.c (cp_parser_member_declaration): Check that
        a constrained friend definition is valid.
        * gcc/cp/decl.c (grokfndecl): Disallow constrained friend template
        specializations.
        * gcc/cp/constraints.cc (check_constrained_friend): New.
        * gcc/cp/typeck.c (cp_build_function_call_vec): Diagnose constraints
        in the presence of the failure of a single candidate.
        * gcc/cp/cp-tree.h (check_constrained_friend): New.
        * gcc/cp/call.c (is_non_template_member_fn): Make inline.
        (is_non_template_friend), (is_constrainable_non_template_fn): New.
        (add_function_candidate): Predicate check on
        is_constrainable_non_template_fn.

2013-09-10  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/cp-tree.h (TEMPLATE_PARMS_CONSTRAINTS): New.
        * gcc/cp/parser.c (cp_parser_template_declaration_after_export),
        (cp_parser_type_parameter): Use TEMPLATE_PARMS_CONSTRAINTS.
        * gcc/cp/semantics.c (fixup_template_scope): Use 
        TEMPLATE_PARMS_CONSTRAINTS.

2013-09-11  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/cxx-pretty-print.c (pp_cxx_compound_requirement),
        (pp_cxx_type_requirement), (pp_cxx_validtype_expr): Use 
        pp->type_id() instead of pp_cxx_type_id().

2013-09-09  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/pt.c (get_class_bindings): Pass the partial specialization
        for constraint evaluation. Evaluate constraints, resulting in
        deduction failure on error.
        (get_specializaing_template_decl), (get_specialization_constraints),
        (maybe_new_partial_specialization): New.
        (maybe_process_partial_specialization): Allow the creation of
        new types for constrained partial specializations.
        (process_partial_specialization): Modify the canonical type
        of constrained partial specializations.
        (instantiate_class_template_1): Do not explicitly check constraints
        during class template instantiation.
        (tsubst_decl): Instantiate the constraints of template declarations.
        (more_specialized_class): Pass specializations to get_class_bindings().
        Compare specialization constraints if the types are equivalent.
        (most_specialized_class): Pass specialization to get_class_bndings().
        * gcc/cp/decl2.c (check_class_fn): Get the decl's requirements from
        either the current template reqs or from the template parameters.
        Allow overloading of constrained out-of-class member definitions.
        * gcc/cp/semantics.c (fixup_template_type): New. Match the template
        scope to a specialization with appropriate constraints.
        (finish_template_type): Fix template type when entering scope.
        * gcc/cp/parser.c (cp_parser_parse_type_parameter): Attach
        requirements to the current template parameter list.
        (cp_parser_init_declarator): Parse requires clauses for out-of-class
        member definitions. Be sure to restore current constraints before
        exiting the function.
        (cp_parser_member_declarator): Restore the previous requirements in
        an early-exit branch.
        (cp_parser_late_parsing_for_member): Restore constraints after
        maybe_end_member_template_processing().
        (cp_parser_template_declaration_after_exp): Attach constraints to
        the current template parameters.
        * gcc/cp/constraint.cc (reduce_template_id): Don't crash when
        omitting ()'s on constraint calls.
        (check_requirements): Don't evaluate dependent arguments.
        (check_constraints): Don't try to evaluate when arguments are
        dependent.
        (equivalent_constraints): Optimize the case when a and b are the
        same constraints.

2013-07-26  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/semantics.c (trait_expr_value): Evaluate __is_same_as.
        (finish_trait_expr): Check __is_same_as and __is_convertible_to.
        * gcc/cp/constraint.cc (diagnose_trait): Diagnose failures in
        __is_same_as.
        * gcc/cp/parser.c (cp_parser_primary_expression), 
        (cp_parser_trait_expr): Parse __is_same_as.
        * gcc/cp/cp-tree.h (cp_trait_kind): Add CPTK_IS_SAME_AS.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_trait_expression): Pretty print
        __is_same_as trait.

2013-07-26  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/tree.c (cp_walk_subtrees): Don't recurse through the
        requires expr parameter list.

2013-07-25  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parser.c (cp_parser_requires_expr): Update parser using new
        requires expression nodes. Renamed some grammar productions to better 
        reflect the representation of the syntax. Create a new scope for 
        requires parameters.
        (cp_parser_nested_requirement): Wrap results in a NESTED_REQ node.        
        * gcc/cp/semantics.c (xvalue_result_type): New.
        (trait_expr_value): Evaluate __is_convertible_to.
        (finish_requires_expr): Implemented, along with other functions to
        construct and evaluate nodes for template constraints.
        (potential_constant_expression_1): Handle requires expressions.
        (finish_template_requirements), (finish_requires_expr), etc:
        Move to constraint.cc.
        * gcc/cp/cp-tree.def: (REQUIRES_EXPR), (EXPR_REQ), (TYPE_REQ),
        (NESTED_REQ), (VALIDEXPR_EXPR), (VALIDTYPE_EXPR), (CONSTEXPR_EXPR):
        New.
        * gcc/cp/cp-objcp-common.c (cp_common_init_ts): Make new nodes typed.
        * gcc/cp/cp-tree.h (finish_expr_requirement), 
        (finish_type_requirement), (finish_nested_requirement),
        (finish_validexpr_expr), (finish_validtype_expr),
        (finish_constexpr_expr): New.
        * gcc/cp/pt.c (convert_nontype_argument): Use can_convert_standard.
        (retrieve_local_specialization), (register_local_specialization),
        (extract_fnparm_pack): Make non-static.
        (tsubst_expr): Substitution rules for requires expressions.
        (instantiate_requirements): Move to constraints.cc
        (tsubst_constraint): Remove.
        * gcc/cp/call.c (can_convert): Allow user-defined conversions.
        (can_convert_standard): New.
        * gcc/cp/cvt.c (convert_to_reference): Use can_convert_standard.
        * gcc/cp/search.c (check_final_overrider): Use can_cnvert_standard.
        * gcc/cp/typeck.c (build_static_cast_1): Use can_convert_standard.
        * gcc/cp/error.c (dump_expr): Pretty print new nodes.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_primary_expression): Pretty
        print new expr/req nodes.
        (pp_cxx_requires_expr): New along with related functions for
        pretty printing requirements.
        (pp_cxx_parameter_declaration_clause): Accommodate "raw" parameter
        lists in addition to function decls.
        (pp_cxx_requirement_parameter_list): Unified with parameter decl clause.
        * gcc/cp/cxx-pretty-print.h (pp_cxx_requires_expr): New along with
        related functions for pretty printing requirements.     
        * gcc/cp/logic.cc: Move header comments to top of file.
        * gcc/cp/constraint.cc (reduce_requirements): Handle requires
        expressions.
        (diagnose_constraints): Rename and handle requires expressions.

2013-07-01  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/error.c (cp_printer): Fix unnecessary whitespace change.
        * gcc/cp/constraint.cc (diagnose_node): Don't fail diagnosing
        disjunctions.

2013-07-01  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/class.c (are_constrained_member_overloads): Fix doc typos.

2013-06-24  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parser.c (cp_parser_init_declarator): Parse template
        requirements for out-of-class member definitions.
        * gcc/cp/decl2.c (check_classfn): Include match out-of-class
        definitions using constraints.
        * gcc/cp/constraint.cc (equivalently_constrained). Use get_constraints.
        (more_constrained). Use get_constraints. 

2013-06-24  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/cp-tree.h (tree_template_info). Remove constraint from 
        template info.
        (check_template_info): Removed (unused).
        (TI_CONSTRAINT): Removed (no longer needed) along with related macros.
        (DECL_CONSTRAINTS): New. Get constraints from DECL_SIZE_UNIT for 
        template decls.
        (build_template_info): Removed overload taking constraints.
        (get_constraints): Removed (no longer needed).
        * gcc/cp/class.c (are_constrained_member_overlaods): Allow constrained 
        member function templates to be differentiated as overloads.
        * gcc/cp/decl.c (decls_match): Only compare constraints on 
        declarations.
        (grokfndecl): Don't pass constraints to build_template_info.
        * gcc/cp/tree.c (bind_template_template_parm): Don't pass constraints 
        to build_template_info.
        * gcc/cp/pt.c (build_template_info): Removed overload taking 
        constraints.
        (check_explicit_specialization): Don't build new constraints for 
        template info.
        (build_template_decl): Pass constraints. Update docs.
        (process_partial_specialization): Stub out support for constrained
        partial specialiations.
        (push_template_decl_real): Build template decls with current template 
        reqs. Don't pass constraints to build_template_info.
        (add_inherited_template_parms): Build new constraints from inherited
        template constructors.
        (redeclare_class_template): Update to new constraint interface.
        (is_compatible_template_arg): Update to new constraint interface.
        (lookup_template_class_1): Don't build new constraints or pass them to
        build_template_info.
        (instantiate_class_template_1): Update to new constraints interface.
        (tsubst_decl): Don't build new constraints or pass them to
        build_template_info. For function templates, explicitly instantiate
        new constraints for member functions of class templates.
        * gcc/cp/semantics.c: Associate constraints with template template 
        parms directly, not through template info.
        * gcc/cp/constraint.cc (get_constraints): Simplified to use new constraints
        interface.
        (check_constraints): Update to use new constraints interface.
        (equivalently_constrained): Update to use new constraints interface.
        (more_constrained): Update to use new constraints interface.
        * gcc/cp/parser.cpp (cp_parser_late_parsing_for_member): Update to use 
        new constraints interface.
        * gcc/cp/call.c (is_non_template_member_fn): New.
        (add_function_candidate): Only check constraints for non-template member
        functions.

2013-06-21  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/parser.c (cp_parser_requires_clause): Pulled out of
        cp_parser_requires_clause_opt for reuse in the requires expr parser.
        (cp_parser_requires_expression): New, along with a family of
        sub-expression parsers for the new feature.
        * gcc/cp/semantics.c (finish_requires_expr): Stub.
        (finish_syntax_requirement): Stub.
        (finish_type_requirement): Stub.
        (finish_constexpr_requirement): Stub.
        (finish_noexcept_requirement): Stub.
        (finish_requires_expr): Stub.
        * gcc/cp/cp-tree.h: (finish_requires_expr): New.
        (finish_syntax_requirement): New.
        (finsih_type_requirement): New.
        (finish_constexpr_requirement): New.
        (finish_noexcept_requirement): New.

2013-06-21  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/error.c (subst_to_string): Allow this to be called explicitly
        passing template parameters in the TREE_TYPE and with a null 
        TREE_PURPOSE.
        * constraint.cc (check_requirements): New overload taking template
        arguments.
        (check_constraints.cc): Move instantiation and checking into the
        new check_requirements overload.
        (diagnose_requirements): New family of functions for diagnosing 
        constraint failures.

2013-06-18  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/class.c (are_constrained_member_overloads): New.
        (add_method): Allow overloading of constrained member functions.
        * gcc/cp/call.c (rejection_reason_code): New rr_constraint_failure.
        (template_constraint_failure): New.
        (add_function_candidate): Check for viability as a precondition to use.
        (add_template_candidate_real): Integrate constraint diagnostics.
        Provide constraint info for new template instantiations.
        (print_z_candidate): Emit diagnostics for constraint failures.
        (template_decl_for_candidate): New.
        (joust): Allow non-member templates of class templates to be evaluated
        in more_specialized_fn if they are constrained.
        * gcc/cp/ptree.c (cxx_print_xnode): Dump constraint info.
        * gcc/cp/semantics.c (finish_template_template_parm): Build template
        info for template template parameters.
        (is_unary_trait): New.
        (is_binary_trait): New.
        (finish_trait_expr): Check for binary traits using new function.
        * gcc/cp/constraint.cc (join_requirements): New
        (conjoin_requirements): Join expressions correctly. Fixed docs.
        (disjoin_requirements): Removed.
        (is_constriant): Removed.
        (resolve_constraint_check): New. Replaces previous get_constraint
        check and related functions.
        (get_constraints): New, along with helper functions.
        (suppress_template_processing): New. 
        (check_template_constraints): New, along with helper functions.
        (equivalent_constraints): New.
        (equivalently_constrained): New.
        (more_constraints): New.
        (more_constrianed): New.
        (diagnose_constraint_failure): New.
        * gcc/cp/decl.c (decls_match): Check for constraint equivalence if
        the types are the same.
        (check_concept_refinement): New.
        (are_constrained_overloads): New.
        (duplicate_decls): Handle constraints for ambigous declarations. Check
        and diagnose concept refinement.
        (check_concept_fn): Don't fail completely just because the concept
        isn't defined correctly. Allow analysis to continue as if declared
        constexpr. Concepts must return bool.
        * gcc/cp/tree.c (bind_template_template_parm): Provide empty 
        constraints for bound template template parameters.
        * gcc/cp/logic.cc: Rewrite of proof state and related structures and
        decomposition logic. Removed right-decomposition logic, but retained
        right-logical rules.
        (match_terms): Renamed from entails.
        (subsumes_prop): Cleanup, added specific handlers for and/or cases.
        (subsumes_constraints): Update from interface change.
        * gcc/cp/cp-tree.h (check_constraint_info): Renamed and applied
        interface change.
        (check_template_info): Renamed and applied interface change.
        (cp_unevaluated): New
        (local_specialization_stack): New.
        (coerce_template_parms): New.
        (is_unary_trait): New.
        (is_binary_trait): New.
        (get_constraints): New.
        (check_constraints): New.
        (check_template_constraints): New.
        (subst_template_constraints): New.
        (equivalent_constraints): New.
        (equivalently_constrained): New.
        (more_constraints): New.
        (more_constrained): New.
        (diagnose_constraints_failure): New.
        * gcc/cp/cxx-pretty-print.c (pp_cxx_template_declaration): Print the
        template requirements.
        * gcc/cp/pt.c (local_specialization_stack): New.
        (build_template_info): Refactor into 3-argument version and 
        incorporate template requirements.
        (check_explicit_specialization): Instantiate requirements for
        template info.
        (push_template_decl_real): Include constraints in template info.
        (redeclare_class_template): Diagnose redeclaration with different
        constraints.
        (is_compatible_template_arg): New.
        (convert_template_argument): Check constraints on template template
        arguments and diagnose errors.
        (lookup_template_class_1): Check constraints on alias templates.
        Keep constraints with instantiated types.
        (instantiate_class_template_1): Check constraints on class templates.
        (tsubst_decl): Instantiate and keep constraints with template info.
        Also, allow dependent pack arguments to produce neww parameter
        packs when instantiated.
        (coerce_template_parms): New overload.
        (tsubst_copy): Handle REAL_TYPE and BOOLEAN_TYPE.
        (tsubst_copy_and_build): PARM_DECLs can be instantiated as pack
        expansions (used with requires expression).
        (fn_type_unification): Check constraints for function templates.
        (more_specialized_fn): Determine which candidate is more constrained.
        (substitute_template_parameters): Removed.
        (tsubst_constraint): New.
        (substitute_requirements): New.
        * gcc/cp/parser.c: (cp_parser_optional) Removed along with helper
        functions, etc.
        (cp_unevaluated): New.
        (cp_parser_type_parameter): Check for requires kw explicitly, and
        save/clear template requirements before parsing the requires clause.
        (cp_parser_requires_clause): Removed.
        (cp_parser_template_declaration_after_exp): Check for requires kw
        explicitly.
        * gcc/system.h (cstdlib): Removed include.
        * gcc/c-family/c-common.h (D_CXX_CONCEPTS): New flag for disabling
        concept keywords.
        * gcc/c-family/c.opt (flag_concepts): Remove redundant declaration.
        * gcc/c-family/c-common.c (c_common_r): Concept-specific keywords
        are only enabled when concepts are enabled.

2013-06-01  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/system.h (cstdlib): Include <cstdlib> to avoid poisoned
        declaration errors.
        * gcc/c-family/common.c (c_common_r): Added __is_same_as intrinsic,
        removed previous, unused intrinsics.
        * gcc/c-family/common.h (rid): Added RID_IS_SAME_AS.
        * gcc/cp/parser.c (take): New.
        (cp_requires_clause): New.
        (cp_requires_clause_opt): New.
        (cp_rule): New.
        (cp_parser_optional_if_token): New.
        (cp_parser_optional_if_not_token): New.
        (cp_parser_optional_if_keyword): New.
        (cp_parser_decl_specifier_seq): Parse 'concept' as a declspec.
        (cp_parser_type_parameter): Parse constrained template template parms.
        (cp_parser_member_specification_opt): Parse member constraints after
        the declaration, not before.
        (cp_parser_template_declaration_after_exp): Rewrote parsing for
        template requirements
        (cp_parser_late_parsing_for_member): Re-push the current template 
        requirements when late-parsing member definitions.
        * gcc/cp/decl.c (check_concept_fn): New.
        (grokfndecl): Semantics for concept declspec.
        (grokdeclarator): Semantics for concept declspec.
        (xref_tag_1): Update to new interface.
        * gcc/cp/constraint.cc (make_constraints): New.
        * gcc/cp/cp-objcp-common.c (cp_tree_size): Add case for constraint_info.
        * gcc/cp/cp-tree.h (require): New.
        (tree_template_info): Add a field for constraint info.
        (tree_constraint_info): New.
        (constraint_info_p): New.
        (template_info_p): New.
        (CI_SPELLING): New.
        (CI_REQUIREMENTS): New.
        (CI_ASSUMPTIONS): New.
        (TI_CONSTRAINT): New.
        (TI_SPELLING): New.
        (TI_REQUIREMENTS): New.
        (TI_ASSUMPTIONS): New.
        (DECL_TEMPLATE_CONSTRAINT): New.
        (CLASSTYPE_TEMPLATE_CONSTRAINT): New.
        (ENUM_TEMPLATE_CONSTRAINT): New.
        (TEMPLATE_TEMPLATE_PARM_TEMPLATE_CONSTRAINT): New.
        (TYPE_TEMPLATE_CONSTRAINT): New.
        (cp_tree_node_structure_enum): Added entry for constraint info.
        (lang_tree_node): Added entry for constraint info.
        (lang_decl_base): Added bit for concept declarations.
        (DECL_DECLARED_CONCEPT_P): New.
        (cp_decl_spec): Added ds_concept declaration specifier.
        * gcc/cp/Make-lang.in (logic.o): New target.
        * gcc/cp/semantics.c (finish_template_requirements): Rewrite.
        * gcc/cp/logic.cc: New
        * gcc/cp-tree.def (CONSTRAINT_INFO): New node.
        * gcc/cp/pt.c (current_template_args): Make non-static.
        (redeclare_class_template): Take constraints as a 3rd argument

2013-04-01  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/Make-lang.in: Add constraints.o target.
        * gcc/cp/cp-tree.h (substitute_template_parameters): Declare.
        (instantiate_requirements): Declare.
        (conjoin_requirements): Declare.
        (disjoin_requirements): Declare.
        (reduce_requirements): Declare.
        * gcc/cp/pt.c (substitute_template_parameters): Define.
        (instantiate_requirements): Define.
        * gcc/cp/pt.c (finish_template_requirements): Call
        reduce_requirements to get constraints.
        * gcc/cp/parser.c (cp_parser_type_parameter): Restore saved
        constraints after parsing template template parameter decl.
        * gcc/cp/constraints.cc: New.

2013-03-11  Andrew Sutton  <andrew.n.sutton@gmail.com>
        
        * gcc/cp/Make-lang.in: Add constraint.c
        * gcc/cp/constraint.c: New
        (conjoin_requirements): New
        (disjoin_requirements): New
        (requirement_reduction): New class
        (reduce_requirements): New
        * gcc/cp/cp-tree.h (reduce_requrements): New
        (conjoin_requirements): New
        (disjoin_requirements): New
        * gcc/cp/cp-tree.h (finish_template_template_parm) Comments.
        * gcc/cp/semantics.c (finish_template_requirements) Start
        working with requirements.


2013-03-01  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/cp/cp-tree.h (saved_scope): Add template requirements.
        (finish_template_requirements): Declare
        * gcc/cp/parser.c (cp_parser_template_requirement_opt): Declare.
        (cp_parser_template_declaration): Document grammar extensions.
        (cp_parser_type_parameter): Parse requirements for template
        template parameters.
        (cp_parser_member_declaration): Parse requirements for
        members of class templates.
        (cp_parser_template_requirement_opt): Define.
        (cp_parser_template_declaration_after_exp): Parse requirements
        for template declarations.
        * gcc/cp/semantics.c (finish_template_requirements): Define.
        * gcc/cp/lex.c (cxx_init): Enable concepts by default.

2013-03-01  Gabriel Dos Reis  <gdr@integrable-solutions.net>

        * lex.c (flag_concepts): Revert left over declaration.

2013-03-01  Gabriel Dos Reis  <gdr@integrable-solutions.net>

        * gcc/c-family/c-common.c (cxx_dialect): Set C++11 as default.
        * gcc/c-family/c.opt(flag_concepts): Add.
        * gcc/cp/lex.c (flag_concepts): New.  Enabled concept support by
        default.

2013-02-28  Andrew Sutton  <andrew.n.sutton@gmail.com>

        * gcc/c-family/c-common.h (rid): New resreserved words for concepts.
        * gcc/c-family/c-common.c (c_common_reswords): Definitions thereof.
        * gcc/doc/extend.texi (write_symbol): Initial concept docs.