@cosmology/ast
Version:
Cosmos TypeScript AST generation
352 lines (319 loc) • 12.5 kB
text/typescript
import * as t from '@babel/types';
import { getFieldOptionality, getOneOfs } from '..';
import { identifier, objectMethod } from '../../../utils';
import { ProtoParseContext } from '../../context';
import { getBaseCreateTypeFuncName } from '../types';
import { ProtoType, ProtoField } from '@cosmology/types';
import { baseTypes, decode } from './utils';
import { BinaryCoder } from '../../../utils/binary-coder-expression';
const needsImplementation = (name: string, field: ProtoField) => {
throw new Error(`need to implement decode (${field.type} rules[${field.rule}] name[${name}])`);
}
export interface DecodeMethod {
typeName: string;
context: ProtoParseContext;
field: ProtoField;
isOptional: boolean;
}
export const decodeMethodFields = (context: ProtoParseContext, name: string, proto: ProtoType) => {
const oneOfs = getOneOfs(proto);
return Object.keys(proto.fields ?? {}).map(fieldName => {
const field = {
name: fieldName,
...proto.fields[fieldName]
};
const isOneOf = oneOfs.includes(fieldName);
const isOptional = getFieldOptionality(context, field, isOneOf);
const args: DecodeMethod = {
typeName: name,
context,
field,
isOptional
};
if (field.rule === 'repeated') {
switch (field.type) {
case 'string':
return decode.array(args, baseTypes.string(args));
case 'bytes':
return decode.array(args, baseTypes.bytes(args));
case 'double':
return decode.tagDelimArray(args, baseTypes.double(args));
case 'bool':
return decode.tagDelimArray(args, baseTypes.bool(args));
case 'float':
return decode.tagDelimArray(args, baseTypes.float(args));
case 'int32':
return decode.tagDelimArray(args, baseTypes.int32(args));
case 'sint32':
return decode.tagDelimArray(args, baseTypes.sint32(args));
case 'uint32':
return decode.tagDelimArray(args, baseTypes.uint32(args));
case 'fixed32':
return decode.tagDelimArray(args, baseTypes.fixed32(args));
case 'sfixed32':
return decode.tagDelimArray(args, baseTypes.sfixed32(args));
case 'int64':
return decode.tagDelimArray(args, baseTypes.int64(args));
case 'sint64':
return decode.tagDelimArray(args, baseTypes.sint64(args));
case 'uint64':
return decode.tagDelimArray(args, baseTypes.uint64(args));
case 'fixed64':
return decode.tagDelimArray(args, baseTypes.fixed64(args));
case 'sfixed64':
return decode.tagDelimArray(args, baseTypes.sfixed64(args));
default:
switch (field.parsedType.type) {
case 'Enum':
return decode.tagDelimArray(args, baseTypes.enum(args));
case 'Type':
return decode.typeArray(args);
}
return needsImplementation(fieldName, field);
}
}
if (field.keyType) {
// currently they all look the same for decode()
return decode.keyHash(args);
}
switch (field.type) {
case 'string':
return decode.string(args);
case 'int32':
return decode.int32(args);
case 'sint32':
return decode.sint32(args);
case 'uint32':
return decode.uint32(args);
case 'fixed32':
return decode.fixed32(args);
case 'sfixed32':
return decode.sfixed32(args);
case 'int64':
return decode.int64(args);
case 'sint64':
return decode.sint64(args);
case 'uint64':
return decode.uint64(args);
case 'fixed64':
return decode.fixed64(args);
case 'sfixed64':
return decode.sfixed64(args);
case 'double':
return decode.double(args);
case 'float':
return decode.float(args);
case 'bytes':
return decode.bytes(args);
case 'bool':
return decode.bool(args);
case 'google.protobuf.Duration':
case 'Duration':
return decode.duration(args);
case 'google.protobuf.Timestamp':
case 'Timestamp':
return decode.timestamp(args);
default:
switch (field.parsedType.type) {
case 'Enum':
return decode.enum(args);
case 'Type':
return decode.type(args);
}
return needsImplementation(fieldName, field);
}
});
};
export const decodeMethod = (context: ProtoParseContext, name: string, proto: ProtoType) => {
BinaryCoder.addUtil(context);
let returnType = name;
// decode can be coupled to API requests
if (context.store.responses[name]) {
// returnType = name + 'SDKType';
returnType = name;
}
return objectMethod(
'method',
t.identifier('decode'),
[
identifier('input',
t.tsTypeAnnotation(
t.tsUnionType(
[
BinaryCoder.getReaderTypeRef(context),
t.tsTypeReference(
t.identifier('Uint8Array')
)
]
)
),
false
),
identifier('length', t.tsTypeAnnotation(
t.tsNumberKeyword()
), true),
...(context.options.interfaces.enabled && context.options.interfaces.useUseInterfacesParams ? [
t.assignmentPattern(
identifier(
'useInterfaces',
t.tsTypeAnnotation(t.tsBooleanKeyword())
),
t.identifier(
(context.pluginValue('interfaces.useByDefault') ?? true).toString()
)
)
] : []),
],
t.blockStatement([
/*
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
*/
t.variableDeclaration(
'const',
[
t.variableDeclarator(
t.identifier('reader'),
t.conditionalExpression(
t.binaryExpression(
'instanceof',
t.identifier('input'),
BinaryCoder.getReaderMemberExp(context)
),
t.identifier('input'),
t.newExpression(
BinaryCoder.getReaderMemberExp(context),
[
t.identifier('input')
]
)
)
)
]
),
/*
let end = length === undefined ? reader.len : reader.pos + length;
*/
t.variableDeclaration(
'let',
[
t.variableDeclarator(
t.identifier('end'),
t.conditionalExpression(
t.binaryExpression('===',
t.identifier('length'),
t.identifier('undefined')
),
t.memberExpression(
t.identifier('reader'),
t.identifier('len')
),
t.binaryExpression(
'+',
t.memberExpression(
t.identifier('reader'),
t.identifier('pos')
),
t.identifier('length')
)
)
)
]
),
/*
const message = createBaseMsgJoinPool();
*/
t.variableDeclaration(
'const',
[
t.variableDeclarator(
t.identifier('message'),
t.callExpression(
//
t.identifier(getBaseCreateTypeFuncName(name)),
[]
)
)
]
),
///////////
///////////
///////////
t.whileStatement(
t.binaryExpression(
'<',
t.memberExpression(
t.identifier('reader'),
t.identifier('pos')
),
t.identifier('end')
),
t.blockStatement([
/// DECODE BODY
t.variableDeclaration(
'const',
[
t.variableDeclarator(
t.identifier('tag'),
t.callExpression(
t.memberExpression(
t.identifier('reader'),
t.identifier('uint32')
),
[]
)
)
]
),
t.switchStatement(
t.binaryExpression(
'>>>',
t.identifier('tag'),
t.numericLiteral(3)
),
[
...decodeMethodFields(context, name, proto),
/*
default:
reader.skipType(tag & 7);
break;
*/
t.switchCase(
null,
[
t.expressionStatement(
t.callExpression(
t.memberExpression(
t.identifier('reader'),
t.identifier('skipType')
),
[
t.binaryExpression(
'&',
t.identifier('tag'),
t.numericLiteral(7)
)
]
)
),
t.breakStatement()
]
)
]
)
])
),
// RETURN STATEMENT
t.returnStatement(
t.identifier('message')
)
]),
false,
false,
false,
t.tsTypeAnnotation(
t.tsTypeReference(
t.identifier(returnType)
)
)
)
};