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

[official-gcc.git] / ChangeLog.concepts

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.