- Get rid of TypeLiteral<T>. It was introduced to read the component
  type of a List<T> at runtime. But we use arrays everywhere else,
  and we can always read the component type of an array type at
  runtime.
- Properly read/write "minor" types (e.g. sint32, sfixed32). The old
  implementation could only read/write data as the "typical" types
  (one per Java type), e.g. java.lang.Integer -> int32, java.lang.Long
  -> int64. So if e.g. an extension specifies sfixed32 as the type, it
  would be read/written in the totally incompatible int32 format.
- Properly serialize repeated packed fields. The old implementation
  doesn't do packed serialization. As an added bonus, and to be more
  aligned with the rest of protobuf nano / main, repeated packable
  extensions can deserialize both packed and non-packed data.
- Split Extension class into a hierarchy so under typical usage a
  large chunk of code dealing with primitive type extensions can be
  removed by ProGuard.

Bug: https://code.google.com/p/android/issues/detail?id=62586
Change-Id: I0d692f35cc2a8ad3a5a1cb3ce001282b2356b041

accessors mode switches proto fields away from being public fields (which is
how MessageNanoPrinter found which fields to print via reflection). Add a
pass through the methods looking for generated accessor methods to print
those as well.

Change-Id: I7c47853ecbd5534086f44b25a89dbbe56f63ed03

Class initializers prevent ProGuard from inlining any methods
because it thinks the class initializer may have side effects.
This is true for static methods, but instance methods can still
be inlined, because to have an instance you will have touched
the class and any class initializers would have run. But
ProGuard only starts inlining instance methods of classes with
class initializers from v4.11b6, and Android uses v4.4 now.

This change tries to avoid the class initializers as much as
possible, by delaying the initialization of the empty array and
some fields' saved defaults until when they're needed. However,
if the message hosts any extensions, they must be public static
final and therefore introducing the class initializer. In that
case we won't bother with lazy initialization.

Change-Id: I00d8296f6eb0023112b93ee135cdb28dbd52b0b8

For nested message objects, don't generate accessor methods because they have
a default value that is not a valid value (null), so there is no reason to have
get/set/has/clear methods for them. Clients and protos (while serializing) can
check against the invalid value to see if it's been set.

Change-Id: Ic63400889581271b8cbcd9c45c84519d4921fd4b

It is a requirement for parsing code to handle packed and unpacked
forms on the wire for repeated packable fields. This change aligns
the javanano's behavior with the java's.

Bonus: optimize array length calculation when parsing repeated
fixed-size-element-type fields.

Bonus 2: lose "xMemoizedSerializedSize" for repeated enum fields,
and make the serialized size calculation match that for repeated
int32 fields.

Change-Id: I8a06103d9290234adb46b0971b5ed155544fe86a

* commit '3e0d99fab8c1da2a8f36637b7bf5e8581143e36a':
  Update MessageNano#toString() to return mostly valid TextFormat.

The output of toString is now aligned with that used by non-nano and C++
runtimes, with the exception of groups. Groups should be serialized using a
camelized name (e.g. "FooBar" rather than "foo_bar") however the nano runtime
does not have information on which fields are groups.

Changes are:
  - bytes fields are output within double-quotes, non-printable characters are
    output as octal escape sequences (i.e. \NNN);
  - field identifiers are output in underscored format;
  - unset fields are not output (rather than printing "null");
  - the type name of the root message is not output.

With these changes the nano toString, normal toString, and C++'s DebugString all
produce equivalent output when given the same message. (Provided that message
uses no deprecated features.)

Change-Id: Id4791d73822846db29344db9f7bc3781c3e183a6

* commit '332076f08a9d46b772fee755832a0e09dd8cb6aa':
  Fix warnings warnings in header files, hide others.

Follow upstream where they have any changes in 2.5.0

Change-Id: I3466e9c11242f533a9dff8c1afef4202dd100f2e

* commit 'ac8e2e150716784a707587ae6e2c8b3a291a2ae7':
  Minimize method count for nanoproto.

- Migrates getCachedSize to the MessageNano parent class to save one method per message.
- Create ExtendableMessageNano parent class for protos with extensions, this saves the
getExtension and setExtension methods on the relevant messages.
- getSerializedSize's default case (with no fields to serialize) also migrate to the
parent class, which saves methods on empty messages.
- Container classes become interfaces to save the constructor.

Change-Id: I81f1a1b6d6a660096835e9df3ea20456655aab4a

* commit '8a15121c1077fe883f428bd27dee6b99e06e48b6':
  Allow for ref-type arrays containing null elements.

Strip the null elements out before serializing the array.
This is helpful in the cases where the user wants to construct
an array of an inexact size for serialization. For example:
User constructs array of size 5 because they anticipate adding
more than 1 element before serialization. Only 3 get added, so
the array looks like [Obj, Obj, Obj, null, null]. This would
curently crash without this CL.

All repeated fields of ref-type elements can contain null
elements: repeated strings, repeated bytes, and repeated
messages/groups.

Change-Id: I117391c868c9a436536d70d6151780e9cc7e8227

Conflicts:
	src/google/protobuf/compiler/javanano/javanano_message_field.cc

* commit 'bb971d53626cb286f8dc491c15d2731001c4891b':
  Implement hashCode() and equals() behind a generator option.

The option is only called 'generate_equals' because:
- equals() is the main thing; hashCode() is there only to
  complement equals();
- it's shorter;
- toString() should not be included in this option because
  it's more for debugging and it's more likely to stop
  ProGuard from working well.

Also shortened the "has bit" expression; was
((bitField & mask) == mask), now ((bitField & mask) != 0).
Both the Java code and the bytecode are slightly shorter.

Change-Id: Ic309a08a60883bf454eb6612679aa99611620e76

* commit '42be1e79ccd670be36220222936aa7cacc6856f6':
  Feature request: set() and clear() accessors return this

Also pre-inlines set() and has() in serialization code. This could
theoretically help ProGuard: the message class size is usually large,
and because of this only, it may refuse to inline an accessor into
the serialization code, and as a result keeps the accessor intact.
Chances are, after pre-inlining all accessor calls within the message
class, those accessors become unused or single-use, so there are more
reasons for ProGuard to inline and then remove them.

Change-Id: I57decbe0b2533c1be21439de0aad15f49c7024dd

* commit 'c50f605c572a425b2fa696fedc5e61ac6f66d2a9':
  Make generated code more aligned with Google Java style.

- Blank line after opening a message class (but not an enum interface).
- Let all code blocks insert blank lines before themselves. This applies to
  'package' statement, all message classes, enum classes or constant groups,
  extensions, bitfields, proto fields (one block per field; i.e. accessors
  don't have blank lines among them), and basic MessageNano methods. In this
  case we don't need to guess what the next block is and create blank lines
  for it.
- Fixed some newline/indent errors.
- Only one SuppressWarnings("hiding") per file.

Change-Id: I865f52ad4fb6ea3b3a98b97ac9d78d19fc46c858

* commit 'afaf74ce55f4aff63dc30e7045a7cd6c1cf232dc':
  Fix repeated field merging semantics.

The public doc states that repeated fields are simply concatenated
and doesn't impose a different semantics for packed fields. This
CL fixes this for packed fields and adds tests covering all cases.

Also fixed a bit of missed null-repeated-field treatments.

Change-Id: Ie35277bb1a9f0b8171dc9d07b6adf9b9d3308de2

* commit '63e819adbb4d2d8215f5d3d8297dc50bf2fe3329':
  Protect against null repeated fields.

* commit 'c85806baedfc98ad5759a990b35ea5b5f1ac4edb':

There's no distinction between a repeated field being null and being
empty. In both cases, nothing is sent on the wire. Clients might for
whatever reason inadvertently set a repeated field to null, so
protect against that and treat it just as if the field was empty.

Change-Id: Ic3846f7f2189d6cfff6f8ef3ca217daecc3c8be7

* commit '39cee9f1f5cd513a53ac5100eb208ed431f99af0':
  Remove all field initializers and let ctor call clear().