Just fetch Value type once rather than each time inlining is done for Num and Int

update docs to show how to call into parent checks

in each subtype inline_as, use the check from the parent rather than repeating the code

Also run the special Str tests on the types that descend from Str (tests still pass).

fix punctuation

punctuation fix

Add Chloro to deps test

Remove JSORB

It may be what's killing Jenkins, and Stevan doesn't seem interested in maintaining it

MooseX::Net::API has been deprecated by the author

better error message for calling superclasses as a writer when immutable

Remove FCGI::Engine

One of its tests, t/020_basic_manager.t, seem to be just hanging forever

Bump version in master

fix changelog

pod coverage and such

add stuff from that test to author requirements

tests for closing over stuff

stop closing over method objects when installing modifiers

also don't close over member tc objects in native delegations

changelog

actually, can't do that, since Moose::Error::Default isa CMOP::Object

we don't need an actual inlined version of this

stop closing over the type constraint object

refactor the default type constraint message logic a bit

stop closing over the method metaobject

changed this to close over the class metaobject if we're using a custom
error class, but there's no real way around that. the whole error system
really needs to be thrown out and redone anyway.

fix setting associated_metaclass and attribute on accessor objects

this only matters for lazy attributes with initializers

don't close over attrs in the constructor unless necessary

close over the coercion sub separately

remove unnecessary(?) code

not sure what the original intent was, but it's certainly not breaking
any aliasing in this form

restructure this method a bit for readability

don't close over the type constraint for inlined tcs

stop closing over $attr in accessor generation

fix up a few spelling and pod issues

Wrap all TC inlining in parens and a do { } block

The parens protect against precedence issues when being used with logical operators.

The do { } block provides each TC its own scope, so that if it defines variables they don't leak out to the enclosing code.

Union inlining should always be surrounded by its own set of parens, for safety

fix up the inlining test

make sure these are defined

these can be undef

there's no reason the suffix has to be fixed length

one more constrained scope in tc inlining

Make sure that every type passes all its tests when unioned with itself

Make sure that inlining union preserves the inline env

Make sure that an enum's inline env works when unioned with another enum (each env has a unique var)

Whenever we inline a type constraint, we need to include its inline environment.

Test every builtin TC as a simple attr's constraint, and as a native Array trait's member TC.

This thoroughly tests that we are propogating the TC's inline environment properly.

Make inline constraints safer ...

If we're defining a temp var - do this in a do {} block to limit its scope and
prevent it from conflicting with another constraint's var.

Don't use return in an inline constraint (this is super bad)

Don't use $_ to iterate over a collection of values in generated code, since
this could easily conflict with the surrounding code.

Don't assume that value that fails a duck type constraint is blessed or we get undef warnings

Don't use $_ when checking member constraints, since that can conflict with $_ used in inlined TC

Add comprehensive test for all builtin types as a simple class attribute and as a native trait attribute

Docs, Delta, and Changes for inline constraints

Rename has_inlined_type_constraint to can_be_inlined

changelog

one more Eval::Closure use

one more fix for unoptimized constraints

stop using a package global for enums, just close over it

also use Eval::Closure in the test

fix a couple of unoptimized constraints

there are still more that need to be fixed i think, but do we really
care about these at all? they're pretty much only useful for
informational purposes, i don't think there's any way to actually
trigger this codepath

confess here, since this should never happen

more readable inlined code

use Eval::Closure rather than doing string eval directly

compare references with == rather than eq

Add tests for a fake regex object ( bless {}, 'Regexp' )

Don't disable 'once' warnings in the whole test

Test that Str can handle return value of substr()

Make sure that Int rejects "1\n" and "\n1" (but Num does accept it)

A name-only subtype now inherits inlining from its parent type

Remove explicit optimized constraint in M::M::TC subclasses

Add inlining code for Role constraint class

Explicitly set the constraint for role type

Enum needs to check that the value is not a ref

Drop optimized subs for all builtins - instead use the inlining code to generate a sub

Fix inline code for ArrayRef & HashRef type - need to check the ref type of
the value before dereferencing it

Fix TODO test to test the right thing in inlining.t

Add a thorough test for inlining TCs, especially testing parameterized types and unions

Export inline_as

Use Moose->throw_error to throw errors

Use an inlined constraint when checking member values for native collection

We don't want two different inline code chunks to use the same var names or else they can clash and cause a warning

This happens in the case of a type union of Str | Int, for example

Remove extra newline

Add inlining for union types

All TC objects (except unions) now have inlining code, and tests for all the variations on calling.

Along the way, fixed the basic constraint generation for the various TC
subclasses, which were not actually setting a proper constraint sub when they
were created.

Inlining parameterized type seems to work, but needs more explicit tests

Add tests for un-parameterized Maybe

Add inlining for parameterizable types - add infrastructure for inlining parameterized, but it needs tests

Rewrite builtin type tests to test optimized, unoptimized, and inlined version of every constraint.

FileHandle is not subtype of GlobRef, since an IO::Handle object does not pass the GlobRef constraint.

Remove use of confess when we should use Moose->throw_error

All non-parameterized types now have inlining code

All tests pass, but we really need explicit tests for unoptimized, optimized, and inline cases

Fix XS for RegexpRef

Move optimized constraint subs to new Builtins package

Move definition of built in types to a separate package just for sanity

typo

pod spelling

edits

update our support policy with regards to supported perl versions

be quieter when cleaning, to make listdeps work better

Add parens around qw() to avoid warning with 5.14

Make the changelog lie less

Assert the correct version of CMOP being installed

pod coverage

changelog

more complete clone implementation

more tests

Make instance cloning go through attribute setters

This way things like weakening will be taken care of.

Add failing test for cloning attrs with weak refs

add Test::Magpie to test-my-deps

Put MooseX::MultiObject back into the list of modules to test