Normalizing line endings in FTs
Improving BufferedDataRecord performance by
1. Removing the base class thus eliminating virtual calls and allowing some methods to be inlined
2. Changing the comparison in IsDBNull
AssociationSetAssociatedWithAssociationSetDeadEnd - adding properties to deal with
different ordering of association and association set ends

In CodeFirst pipeline there is an assumptions that AssociationSet Ends
are in the same order as Association Ends. In general this does not have
to be true. Due to this assumption when dealing with arbitrary StoreItemCollections
SSDLSerializer would write an invalid SSDL. The fix is to add properties for
SourceEnd and TargetEnd so that they return ends based on the name and not on
the order and use those in the SSDL Serializer.
Removing .gitattributes
Normalizing more line endings.
TheAssertDoesProtestTooMuchMeThinks (Remove assert that was causing Debug build test failures.)
TheReturnOfTheAssert - fix for issue 839 - Test failures on debug build

The change c8dc3155b216 caused failure on debug build since it was calling into wrapper properties that in some asserted since the metadata was not set readonly. The fix is to directly call into MetadataWorkspace.
Reverted Assert removal
Successfully re-ran all the UnitTests on debug build.
PapaDontPreachToTheMaterializerGirl (Remove explicit security checks from materializer)

This change removes the explicit demands, asserts, and other checks that the materializer was doing. The idea here is that if the both the app assembly and the EF assembly are running in partial trust (without a trust boundary between the assemblies) then the materializer will work because access to the EF internals through the equivalent of Reflection is allowed. This should also allow mapping to privates, which was previously not supported. If the app tries to map to a member that it cannot access, then EF also can't access it, and materialization will fail--as it would before. If both the app and EF are in full trust, then everything will work as before.

I will be adding specific partial trust testing after more of the issues have been fixed.
YouMayTouchTheArtifacts (Remove explicit file permissions checks from metadata cache/loader)

Metadata is cached in the app domain. This change removes explicit checks that the thread accessing the cached metadata has permission to access the file from which it was previously loaded. This check kind of made sense in a heterogeneous app domain, but really doesn't make sense with current .NET security and with the current plan for EF partial trust where the EF assembly is running without a trust barrier between it and the app assembly.
ExceptionToastCrunch (Use partial trust-safe serialization pattern for exceptions.)

Switching exceptions to use the pattern introduced in .NET 4 that makes use of ISafeSerializationData to avoid the need to override the SafetyCritical GetObjectData method.
ComBomb (Fix NET40 build break caused by use of Exception.HResult which is public in 4.5 but protected in 4.0)
Quarantining FunctionalTest files (and their dependencies) that take advantage of EntityFramework's InternalsVisibleTo attribute.
SayYesToUnicorns (Replace use of IsValidLanguageIndependentIdentifier)

We were using CodeGenerator.IsValidLanguageIndependentIdentifier as part of the check for valid EDM names. This method cannot be called in partial trust. However, we were only using this method if it had already matched our own regex first. In writing tests for this it became apparent that if the string passed our own regex then it would always pass IsValidLanguageIndependentIdentifier unless it contained a character of category 'Other, Format' (Cf). I changed our regex to not allow this and we therefore don't need the additional check at all anymore.
A DBA's Joy

Code First: Initial support of modification function mapping.

- By-convention metadata generation triggered by EntityTypeConfiguration.MapToFunctions FI stub.
- Updates serializers for function metadata.
- Adds MapToFunctions to Lightweight conventions.
- Adds UTs/FTs and also enables all existing CF FTs to run with function mappings.

Not in this commit:

- Design meeting changes
- Optimistic concurrency
- Many-to-many
Testing line endings
Testing line endings
Fixing line endings
Removing LF test
ResolutionWhichWontFailByFeb1 - enabling passing dependency resolver to EntityCommand

EF runtime uses configuration to resolve dependencies. Once configuration is set it is
sealed and is supposed to be immutable. This does not work for the designer where the user
can add/remove edmx files multiple times and therefore can change providers many times
during the session. To talk to providers we use EntityCommand. Allowing to pass own
resolver to EntityCommand enables sending queries to multiple providers during one session.
Adding SQL Azure ExecutionStrategy.
By default it isn't enabled, but the transient exceptions will be wrapped in an exception that explains how to enable it.