Some changes to the ObjC code generator to support importing into Google.

For messages that have multiple extension ranges, this will improve things
by avoiding repeated work.  For messages with a single range, it should
be a wash.

- Sort the list of set extensions once during serialization and reuse the list.
- Break out of the serialization loop as soon as the loop has moved pasted at
  accepted range for field ids.

* Fix most of the unused variable warnings in Ruby tests

* Add encoded_field_b back in tests/common_tests.rb

* Update README.md

* Migrate to new `ctx.actions` API

This allows building with --incompatible_new_actions_api.

* Fix typo

- removed use of GOOGLE_DISALLOW_EVIL_CONSTRUCTORS
  in favor of deleting them C++11 style.
- removed forward declarations of protobuf core types.
- ensured that namespaces "google" and "protobuf" are
  always opened/closed together.

Make sure to install stubs/strutil.h

Generated code now pulls in this header transitively, so it needs to be
installed.

If a proto has multiple extension ranges back to back, don't double
print the first items as they also are the ending range of the
previous.

Using NSCoding with a Message that has extensions is risky because
when reloaded, there is no way to provide a registry through the
NSCoding plumbing, so output a warnings to atleast give developers
a hint about the potential issues.

Removed stubs/singleton.h

cpp_generator: Add generator options for --cpp_out.

The builds were failing under Xcode 10 because of the new build system.
Even when reverted to the old build system, the build was failing
on the analyzer and swift bridging header, so it seems the general
logic for searching for things was changed in a way the setting does
not always cover.

- Disable HeaderMaps.
- Set user header search paths instead of system search paths.
- Turn off always search user paths (now recommended).

Tested in Xcode 10.1 and 9.4.1; both are able to build/pass with this.

Previously --cpp_out:lite was available to force the optimization mode
to the lite runtime. This adds --cpp_out=speed:...
which is needed to override the file specific options in cases where
libprotobuf-mutator is used for fuzzing since it depends on reflection.
Signed-off-by: Allen Webb <allenwebb@google.com>

compiler/cpp: replace NULL with nullptr

This avoids compiler errors/warnings if zero-as-null-pointer-constant is
considered an error or warning.

This header is no longer used, so we can delete it. I also tweaked
Makefile.am to fix the distcheck test.

* Increase C# default recursion limit to 100

This matches the Java and C++ defaults.

* Change compatibility tests to use execution-time default recursion limit

This way the same tests should pass against all versions, even
if the recursion limit changes. (The tests will be testing whether
different messages work, admittedly - but that's probably fine.)

Add missing include guard to zip_writer.h

Integrated internal changes from Google

Import versions from @bazel_skylib//lib:versions.bzl

options: reserved extension range for CSI

Add wire_format_lite_inl.h include to implicit_weak_message.cc

We have code for converting C/C++/Objc keywords that appear in protos
to convert them so that they can be compiled.
One of the things we need to be careful of is accidentally overriding methods
that Apple declares in NSObject. It turns out that we have run into issues
where we conflict with "hidden" methods in NSObject or methods added by
categories. method_dump.sh collects all of the methods we care about for
macOS and iOS and dumps them into objectivec_nsobject_methods.h which
is then included in objectivec_helpers.cc as part of the build.

Added a pile of tests to verify that conversions are happening as expected.

Add Dart example.

This unbreaks the Windows shared-library build of Chrome when using
Clang versions based on r344987 or later, see https://crbug.com/901776

implicit_weak_message.cc is part of protobuf_lite.dll, and it includes
wire_format_lite.h, which includes the dllexport inline function
WireFormatLite::WriteGroupToArray which will therefore be emitted.

WriteGroupToArray in turn calls the inline function
InternalWriteGroupToArray, however that definition is provided in the
_inl file. To make sure the definition is available, the _inl file must
be included.

Before Clang r344987 the build worked anyway due to luck, because
InternalWriteGroupToArray was emitted into other object files (e.g. in
wire_format_lite.obj). After that Clang revision, those definitions
started getting inlined, and so are longer available and cause a link
failure for the reference from implicit_weak_message.obj.