Add tests for proto targets and support valid edition 2023 inputs

Author: mkruskal-google

cli/targets/proto.js

@@ -102,7 +102,7 @@ function buildRoot(root) {
     if (pkg.length)
         out.push("", "package " + pkg.join(".") + ";");
 
-    buildOptions(ptr);
+    buildOptions(ptr, ["edition", "syntax"]);
     ptr.nestedArray.forEach(build);
 }
 
@@ -184,8 +184,12 @@ function buildType(type) {
 }
 
 function buildField(field, passExtend) {
-    if (field.partOf || field.declaringField || field.extend !== undefined && !passExtend)
+    if (field.partOf && !field.partOf.isProto3Optional) {
         return;
+    }
+    if (field.declaringField || field.extend !== undefined && !passExtend) {
+        return;
+    }
     if (first) {
         first = false;
         push("");
@@ -199,8 +203,10 @@ function buildField(field, passExtend) {
         sb.push("map<" + field.keyType + ", " + field.type + ">");
     else if (field.repeated)
         sb.push("repeated", field.type);
-    else if (syntax === 2 || field.parent.group)
+    else if (syntax === 2)
         sb.push(field.required ? "required" : "optional", field.type);
+    else if (syntax === 3 && field.hasPresence)
+        sb.push("optional", field.type);
     else
         sb.push(field.type);
     sb.push(underScore(field.name), "=", field.id);
@@ -211,7 +217,7 @@ function buildField(field, passExtend) {
 }
 
 function buildGroup(field) {
-    push(field.rule + " group " + field.resolvedType.name + " = " + field.id + " {");
+    push((field.rule || "optional") + " group " + field.resolvedType.name + " = " + field.id + " {");
     ++indent;
     buildOptions(field.resolvedType);
     first = true;
@@ -223,20 +229,16 @@ function buildGroup(field) {
 }
 
 function buildFieldOptions(field) {
-    var keys;
-    if (!field.options || !(keys = Object.keys(field.options)).length)
-        return null;
+    var keys = [];
+    if (field.options) {
+        keys = Object.keys(field.options);
+    }
     var sb = [];
     keys.forEach(function(key) {
+        if (key === "proto3_optional" || key === "packed" || key.startsWith("features.")) return;
+
         var val = field.options[key];
-        var wireType = types.packed[field.resolvedType instanceof Enum ? "int32" : field.type];
         switch (key) {
-            case "packed":
-                val = Boolean(val);
-                // skip when not packable or syntax default
-                if (wireType === undefined || syntax === 3 === val)
-                    return;
-                break;
             case "default":
                 if (syntax === 3)
                     return;
@@ -253,6 +255,14 @@ function buildFieldOptions(field) {
         }
         sb.push(key + "=" + val);
     });
+    var packable = types.packed[field.resolvedType instanceof Enum ? "int32" : field.type];
+    if (packable !== undefined) {
+        if (field.packed && syntax == 2) {
+            sb.push("packed=true");
+        } else if(!field.packed && syntax == 3) {
+            sb.push("packed=false");
+        }
+    }
     return sb.length
         ? "[" + sb.join(", ") + "]"
         : null;
@@ -282,6 +292,10 @@ function consolidateExtends(nested) {
 }
 
 function buildOneOf(oneof) {
+    if (oneof.isProto3Optional) {
+        return;
+    }
+
     push("");
     push("oneof " + underScore(oneof.name) + " {");
     ++indent; first = true;
@@ -311,11 +325,12 @@ function buildMethod(method) {
     push(method.type + " " + method.name + " (" + (method.requestStream ? "stream " : "") + method.requestType + ") returns (" + (method.responseStream ? "stream " : "") + method.responseType + ");");
 }
 
-function buildOptions(object) {
+function buildOptions(object, ignore = []) {
     if (!object.options)
         return;
     first = true;
     Object.keys(object.options).forEach(function(key) {
+        if (ignore.includes(key) || key.startsWith("features.")) return;
         if (first) {
             first = false;
             push("");

cli/targets/static.js

@@ -362,24 +362,8 @@ function toJsType(field, parentIsInterface = false) {
     return type;
 }
 
-function hasPresence(field) {
-    if (field.repeated || field.map) {
-        return false;
-    }
-    return field.partOf || // oneofs
-        field.declaringField || field.extensionField || // extensions
-        field._features.field_presence === "EXPLICIT";
-}
-
-function isProto3Optional(oneof) {
-
-    if (oneof.fieldsArray == null || oneof.fieldsArray.length !== 1) {
-        return false;
-    }
-
-    var field = oneof.fieldsArray[0];
-
-    return field.options != null && field.options["proto3_optional"] === true;
+function isNullable(field) {
+    return field.hasPresence && !field.required
 }
 
 function buildType(ref, type) {
@@ -400,7 +384,7 @@ function buildType(ref, type) {
                 // Implicit fields (proto3), maps and lists can be omitted, but if specified must be non-null
                 // Implicit fields will take their default value when the message is constructed
                 if (field.optional) {
-                    if (hasPresence(field)) {
+                    if (isNullable(field)) {
                         jsType = jsType + "|null|undefined";
                         nullable = true;
                     }
@@ -448,7 +432,7 @@ function buildType(ref, type) {
                 // With semantic nulls, fields are nullable if they are explicitly optional or part of a one-of
                 // Maps, repeated values and fields with implicit defaults are never null after construction
                 // Members are never undefined, at a minimum they are initialized to null
-                if (hasPresence(field) && field.optional) {
+                if (isNullable(field)) {
                     jsType = jsType + "|null";
                 }
             }
@@ -472,7 +456,7 @@ function buildType(ref, type) {
         // With semantic nulls, only explict optional fields and one-of members are null by default
         // Otherwise use field.optional, which doesn't consider proto3, maps, repeated fields etc.
         var nullDefault = config["null-semantics"]
-            ? hasPresence(field) && field.optional
+            ? isNullable(field)
             : field.optional && config["null-defaults"];
         if (field.repeated)
             push(escapeName(type.name) + ".prototype" + prop + " = $util.emptyArray;"); // overwritten in constructor
@@ -504,7 +488,7 @@ function buildType(ref, type) {
         }
         oneof.resolve();
         push("");
-        if (isProto3Optional(oneof)) {
+        if (oneof.isProto3Optional) {
             push("// Virtual OneOf for proto3 optional field");
         }
         else {

src/field.js

@@ -228,6 +228,23 @@ Object.defineProperty(Field.prototype, "packed", {
     }
 });
 
+/**
+ * Determines whether this field tracks presence.
+ * @name Field#hasPresence
+ * @type {boolean}
+ * @readonly
+ */
+Object.defineProperty(Field.prototype, "hasPresence", {
+    get: function() {
+        if (this.repeated || this.map) {
+            return false;
+        }
+        return this.partOf || // oneofs
+            this.declaringField || this.extensionField || // extensions
+            this._features.field_presence !== "IMPLICIT";
+    }
+});
+
 /**
  * @override
  */

src/oneof.js

@@ -171,6 +171,25 @@ OneOf.prototype.onRemove = function onRemove(parent) {
     ReflectionObject.prototype.onRemove.call(this, parent);
 };
 
+/**
+ * Determines whether this field corresponds to a synthetic oneof created for
+ * a proto3 optional field.  No behavioral logic should depend on this, but it
+ * can be relevant for reflection.
+ * @name OneOf#isProto3Optional
+ * @type {boolean}
+ * @readonly
+ */
+Object.defineProperty(OneOf.prototype, "isProto3Optional", {
+    get: function() {
+        if (this.fieldsArray == null || this.fieldsArray.length !== 1) {
+            return false;
+        }
+
+        var field = this.fieldsArray[0];
+        return field.options != null && field.options["proto3_optional"] === true;
+    }
+});
+
 /**
  * Decorator function as returned by {@link OneOf.d} (TypeScript).
  * @typedef OneOfDecorator