Replace newString() with stringPointer() or just &s where the compiler allows this.

mojom/mojom_parser/serialization/serialization.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package serialization
 
 import (
         "fmt"
         "mojo/public/go/bindings"
         "mojom/mojom_parser/generated/mojom_files"
@@ skipping 48 matching lines @@
 }
 
 // translateMojomFile translates from a mojom.MojomFile (the pure Go
 // representation used by the parser) to a mojom_files.MojomFile (the
 // Mojo Go representation used for serialization.)
 func translateMojomFile(f *mojom.MojomFile) (file mojom_files.MojomFile) {
         // file_name field
         file.FileName = f.CanonicalFileName
 
         // module_namespace field
-        file.ModuleNamespace = newString(f.ModuleNamespace)
+        file.ModuleNamespace = &f.ModuleNamespace
 
         // attributes field
         if f.Attributes != nil {
                 file.Attributes = new([]mojom_types.Attribute)
                 for _, attr := range f.Attributes.List {
                         *(file.Attributes) = append(*(file.Attributes), translateMojomAttribute(&attr))
                 }
         }
 
         // imports field
@@ skipping 296 matching lines @@
 }
 
 func translateMapType(mapType mojom.MapTypeRef) *mojom_types.TypeMapType {
         return &mojom_types.TypeMapType{mojom_types.MapType{
                 Nullable:  mapType.Nullable(),
                 KeyType:   translateTypeRef(mapType.KeyType()),
                 ValueType: translateTypeRef(mapType.ValueType())}}
 }
 
 func translateUserTypeRef(userType *mojom.UserTypeRef) *mojom_types.TypeTypeReference {
-        typeKey := newString(userType.ResolvedType().TypeKey())
-        identifier := newString(userType.Identifier())
+        typeKey := stringPointer(userType.ResolvedType().TypeKey())
+        identifier := stringPointer(userType.Identifier())
         return &mojom_types.TypeTypeReference{mojom_types.TypeReference{
                 Nullable:           userType.Nullable(),
                 IsInterfaceRequest: userType.IsInterfaceRequest(),
                 Identifier:         identifier,
                 TypeKey:            typeKey}}
 }
 
 func translateValueRef(valueRef mojom.ValueRef) mojom_types.Value {
         switch valueRef := valueRef.(type) {
         case mojom.LiteralValue:
@@ skipping 53 matching lines @@
                 builtInValue.Value = mojom_types.BuiltinConstantValue_DoubleNegativeInfinity
         case mojom.SimpleTypeDouble_NAN:
                 builtInValue.Value = mojom_types.BuiltinConstantValue_DoubleNegativeInfinity
         default:
                 panic(fmt.Sprintf("Unrecognized BuiltInConstantValue %v", t))
         }
         return &builtInValue
 }
 
 func translateUserValueRef(r *mojom.UserValueRef) *mojom_types.ValueUserValueReference {
-        valueKey := newString(r.ResolvedDeclaredValue().ValueKey())
+        valueKey := stringPointer(r.ResolvedDeclaredValue().ValueKey())
         return &mojom_types.ValueUserValueReference{mojom_types.UserValueReference{
                 Identifier:            r.Identifier(),
                 ValueKey:              valueKey,
                 ResolvedConcreteValue: translateConcreteValue(r.ResolvedConcreteValue())}}
 }
 
 func translateConcreteValue(v mojom.ConcreteValue) mojom_types.Value {
         switch t := v.(type) {
         case mojom.BuiltInConstantValue:
                 return translateBuiltInConstantValue(t)
@@ skipping 21 matching lines @@
                 declData.Attributes = new([]mojom_types.Attribute)
                 for _, attr := range d.Attributes().List {
                         *(declData.Attributes) = append(*(declData.Attributes), translateMojomAttribute(&attr))
                 }
         }
 
         // min_version field
         // TODO(rudominer) Eliminate the min_version field from struct DeclarationData
 
         // short_name field
-        declData.ShortName = newString(d.SimpleName())
+        declData.ShortName = stringPointer(d.SimpleName())
 
         // full_identifier field
-        declData.FullIdentifier = newString(d.FullyQualifiedName())
+        declData.FullIdentifier = stringPointer(d.FullyQualifiedName())
 
         // declared_ordinal field
         if d.DeclaredOrdinal() < 0 {
                 declData.DeclaredOrdinal = -1
         } else {
                 declData.DeclaredOrdinal = int32(d.DeclaredOrdinal())
         }
 
         // declaration_order
         // TODO(rudominer) DeclarationOrder is currently not populated.
@@ skipping 28 matching lines @@
                 }
         }
         return &declarations
 }
 
 func translateMojomAttribute(a *mojom.MojomAttribute) (attribute mojom_types.Attribute) {
         // TODO(rudominer) Improve representation of attribute values.
         return mojom_types.Attribute{a.Key, fmt.Sprintf("%v", a.Value.Value())}
 }
 
-// newString is a convenience function for creating a pointer to a string whose value
-// is the specified string. It is necessary to create pointers to strings because
-// that is how the Mojom type string? (i.e. nullable string) is represented in
+// stringPointer is a convenience function for creating a pointer to a string whose value
+// is the specified string. It may be used in situations where the compiler will
+// not allow you to take the address of a string value directly, such as the
+// return value of a function. It is necessary to create pointers to strings because
+// that is how the Mojom type |string?| (i.e. nullable string) is represented in
 // in the Mojom Go bindings.
-func newString(s string) *string {
-        t := new(string)
-        *t = s
-        return t
+func stringPointer(s string) *string {
+        return &s
 }