operations = new TreeSet<>(topDownIndex.getContainedOperations(
model.expectShape(serviceShapeId)));
Model.Builder modelBuilder = model.toBuilder();
for (OperationShape operation : operations) {
ShapeId operationId = operation.getId();
LOGGER.info(() -> "building unique input/output shapes for " + operationId);
StructureShape newInputShape = operation.getInput()
.map(shapeId -> cloneOperationShape(
service, operationId, (StructureShape) model.expectShape(shapeId), "Input"))
.orElseGet(() -> emptyOperationStructure(service, operationId, "Input"));
StructureShape newOutputShape = operation.getOutput()
.map(shapeId -> cloneOperationShape(
service, operationId, (StructureShape) model.expectShape(shapeId), "Output"))
.orElseGet(() -> emptyOperationStructure(service, operationId, "Output"));
// Add new input/output to model
modelBuilder.addShape(newInputShape);
modelBuilder.addShape(newOutputShape);
// Update operation model with the input/output shape ids
modelBuilder.addShape(operation.toBuilder()
.input(newInputShape.toShapeId())
.output(newOutputShape.toShapeId())
.build());
}
return modelBuilder.build();
}
private static StructureShape emptyOperationStructure(ServiceShape service, ShapeId opShapeId, String suffix) {
return StructureShape.builder()
.id(ShapeId.fromParts(CodegenUtils.getSyntheticTypeNamespace(), opShapeId.getName(service) + suffix))
.addTrait(Synthetic.builder().build())
.addTrait(new BackfilledInputOutputTrait())
.build();
}
private static StructureShape cloneOperationShape(
ServiceShape service,
ShapeId operationShapeId,
StructureShape structureShape,
String suffix
) {
return (StructureShape) cloneShape(structureShape, operationShapeId.getName(service) + suffix);
}
private static Shape cloneShape(Shape shape, String cloneShapeName) {
ShapeId cloneShapeId = ShapeId.fromParts(CodegenUtils.getSyntheticTypeNamespace(), cloneShapeName);
AbstractShapeBuilder builder = Shape.shapeToBuilder(shape)
.id(cloneShapeId)
.addTrait(Synthetic.builder()
.archetype(shape.getId())
.build());
shape.members().forEach(memberShape -> {
builder.addMember(memberShape.toBuilder()
.id(cloneShapeId.withMember(memberShape.getMemberName()))
.build());
});
return (Shape) builder.build();
}
}
ApplicationProtocol.java 0000664 0000000 0000000 00000006730 15102203672 0036323 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.Objects;
import software.amazon.smithy.codegen.core.Symbol;
/**
* Represents the resolves {@link Symbol}s and references for an
* application protocol (e.g., "http", "mqtt", etc).
*/
public final class ApplicationProtocol {
private final String name;
private final Symbol requestType;
private final Symbol responseType;
/**
* Creates a resolved application protocol.
*
* @param name The protocol name (e.g., http, mqtt, etc).
* @param requestType The type used to represent request messages for the protocol.
* @param responseType The type used to represent response messages for the protocol.
*/
public ApplicationProtocol(
String name,
Symbol requestType,
Symbol responseType
) {
this.name = name;
this.requestType = requestType;
this.responseType = responseType;
}
/**
* Creates a default HTTP application protocol.
*
* @return Returns the created application protocol.
*/
public static ApplicationProtocol createDefaultHttpApplicationProtocol() {
return new ApplicationProtocol(
"http",
createHttpSymbol("Request"),
createHttpSymbol("Response")
);
}
private static Symbol createHttpSymbol(String symbolName) {
return SymbolUtils.createPointableSymbolBuilder(symbolName, SmithyGoDependency.SMITHY_HTTP_TRANSPORT)
.build();
}
/**
* Gets the protocol name.
*
* All HTTP protocols should start with "http".
* All MQTT protocols should start with "mqtt".
*
* @return Returns the protocol name.
*/
public String getName() {
return name;
}
/**
* Checks if the protocol is an HTTP based protocol.
*
* @return Returns true if it is HTTP based.
*/
public boolean isHttpProtocol() {
return getName().startsWith("http");
}
/**
* Gets the symbol used to refer to the request type for this protocol.
*
* @return Returns the protocol request type.
*/
public Symbol getRequestType() {
return requestType;
}
/**
* Gets the symbol used to refer to the response type for this protocol.
*
* @return Returns the protocol response type.
*/
public Symbol getResponseType() {
return responseType;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (!(o instanceof ApplicationProtocol)) {
return false;
}
ApplicationProtocol that = (ApplicationProtocol) o;
return requestType.equals(that.requestType)
&& responseType.equals(that.responseType);
}
@Override
public int hashCode() {
return Objects.hash(requestType, responseType);
}
}
ClientOptions.java 0000664 0000000 0000000 00000023654 15102203672 0035134 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import static software.amazon.smithy.go.codegen.GoWriter.goDocTemplate;
import static software.amazon.smithy.go.codegen.GoWriter.goTemplate;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import software.amazon.smithy.go.codegen.auth.AuthSchemeResolverGenerator;
import software.amazon.smithy.go.codegen.integration.AuthSchemeDefinition;
import software.amazon.smithy.go.codegen.integration.ConfigField;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.auth.AnonymousDefinition;
import software.amazon.smithy.model.knowledge.ServiceIndex;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.traits.synthetic.NoAuthTrait;
import software.amazon.smithy.utils.MapUtils;
/**
* Implements codegen for service client config.
*/
public class ClientOptions implements GoWriter.Writable {
public static final String NAME = "Options";
private final ProtocolGenerator.GenerationContext context;
private final ApplicationProtocol protocol;
private final List fields;
private final Map authSchemes;
public ClientOptions(ProtocolGenerator.GenerationContext context, ApplicationProtocol protocol) {
this.context = context;
this.protocol = protocol;
this.fields = context.getIntegrations().stream()
.flatMap(it -> it.getClientPlugins(context.getModel(), context.getService()).stream())
.flatMap(it -> it.getConfigFields().stream())
.distinct()
.sorted(Comparator.comparing(ConfigField::getName))
.toList();
this.authSchemes = context.getIntegrations().stream()
.flatMap(it -> it.getClientPlugins(context.getModel(), context.getService()).stream())
.flatMap(it -> it.getAuthSchemeDefinitions().entrySet().stream())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}
@Override
public void accept(GoWriter writer) {
writer.write(generate());
}
private GoWriter.Writable generate() {
var apiOptionsDocs = goDocTemplate(
"Set of options to modify how an operation is invoked. These apply to all operations "
+ "invoked for this client. Use functional options on operation call to modify this "
+ "list for per operation behavior."
);
return goTemplate("""
$protocolTypes:W
type $options:L struct {
$apiOptionsDocs:W
APIOptions []func($stack:P) error
$fields:W
$protocolFields:W
}
$copy:W
$getIdentityResolver:W
$helpers:W
""",
MapUtils.of(
"protocolTypes", generateProtocolTypes(),
"apiOptionsDocs", apiOptionsDocs,
"options", NAME,
"stack", SmithyGoTypes.Middleware.Stack,
"fields", GoWriter.ChainWritable.of(fields.stream().map(this::writeField).toList()).compose(),
"protocolFields", generateProtocolFields(),
"copy", generateCopy(),
"getIdentityResolver", generateGetIdentityResolver(),
"helpers", generateHelpers()
));
}
private GoWriter.Writable generateProtocolTypes() {
ensureSupportedProtocol();
return goTemplate("""
type HTTPClient interface {
Do($P) ($P, error)
}
""", GoStdlibTypes.Net.Http.Request, GoStdlibTypes.Net.Http.Response);
}
private GoWriter.Writable writeField(ConfigField field) {
GoWriter.Writable docs = writer -> {
field.getDocumentation().ifPresent(writer::writeDocs);
field.getDeprecated().ifPresent(s -> {
if (field.getDocumentation().isPresent()) {
writer.writeDocs("");
}
writer.writeDocs(String.format("Deprecated: %s", s));
});
};
return goTemplate("""
$W
$L $P
""", docs, field.getName(), field.getType());
}
private GoWriter.Writable generateProtocolFields() {
ensureSupportedProtocol();
return goTemplate("""
$1W
HTTPClient HTTPClient
$6W
Interceptors $7T
$2W
AuthSchemeResolver $4L
$3W
AuthSchemes []$5T
$8W
AuthSchemePreference []string
""",
goDocTemplate("The HTTP client to invoke API calls with. "
+ "Defaults to client's default HTTP implementation if nil."),
goDocTemplate("The auth scheme resolver which determines how to authenticate for each operation."),
goDocTemplate("The list of auth schemes supported by the client."),
AuthSchemeResolverGenerator.INTERFACE_NAME,
SmithyGoTypes.Transport.Http.AuthScheme,
goDocTemplate("Client registry of operation interceptors."),
SmithyGoDependency.SMITHY_HTTP_TRANSPORT.struct("InterceptorRegistry"),
goDocTemplate("Priority list of preferred auth scheme names (e.g. sigv4a)."));
}
private GoWriter.Writable generateCopy() {
return goTemplate("""
// Copy creates a clone where the APIOptions list is deep copied.
func (o $1L) Copy() $1L {
to := o
to.APIOptions = make([]func($2P) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
to.Interceptors = o.Interceptors.Copy()
return to
}
""", NAME, SmithyGoTypes.Middleware.Stack);
}
private GoWriter.Writable generateGetIdentityResolver() {
return goTemplate("""
func (o $L) GetIdentityResolver(schemeID string) $T {
$W
$W
return nil
}
""",
NAME,
SmithyGoTypes.Auth.IdentityResolver,
GoWriter.ChainWritable.of(
ServiceIndex.of(context.getModel())
.getEffectiveAuthSchemes(context.getService()).keySet().stream()
.filter(authSchemes::containsKey)
.map(trait -> generateGetIdentityResolverMapping(trait, authSchemes.get(trait)))
.toList()
).compose(false),
generateGetIdentityResolverMapping(NoAuthTrait.ID, new AnonymousDefinition()));
}
private GoWriter.Writable generateGetIdentityResolverMapping(ShapeId schemeId, AuthSchemeDefinition scheme) {
return goTemplate("""
if schemeID == $S {
return $W
}""", schemeId.toString(), scheme.generateOptionsIdentityResolver());
}
private GoWriter.Writable generateHelpers() {
return writer -> {
writer.write("""
$W
func WithAPIOptions(optFns ...func($P) error) func(*Options) {
return func (o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
""",
goDocTemplate(
"WithAPIOptions returns a functional option for setting the Client's APIOptions option."
),
SmithyGoTypes.Middleware.Stack);
fields.stream().filter(ConfigField::getWithHelper).filter(ConfigField::isDeprecated)
.forEach(configField -> {
writer.writeDocs(configField.getDeprecated().get());
writeHelper(writer, configField);
});
fields.stream().filter(ConfigField::getWithHelper).filter(Predicate.not(ConfigField::isDeprecated))
.forEach(configField -> {
writer.writeDocs(
String.format(
"With%s returns a functional option for setting the Client's %s option.",
configField.getName(), configField.getName()));
writeHelper(writer, configField);
});
};
}
private void writeHelper(GoWriter writer, ConfigField configField) {
writer.write("""
func With$1L(v $2P) func(*Options) {
return func(o *Options) {
o.$1L = v
}
}
""", configField.getName(), configField.getType());
}
private void ensureSupportedProtocol() {
if (!protocol.isHttpProtocol()) {
throw new UnsupportedOperationException("Protocols other than HTTP are not yet implemented: " + protocol);
}
}
}
CodegenUtils.java 0000664 0000000 0000000 00000035576 15102203672 0034735 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.knowledge.GoPointableIndex;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeType;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.traits.RequiredTrait;
import software.amazon.smithy.model.traits.TitleTrait;
import software.amazon.smithy.utils.StringUtils;
/**
* Utility methods likely to be needed across packages.
*/
public final class CodegenUtils {
private static final Logger LOGGER = Logger.getLogger(CodegenUtils.class.getName());
private static final String SYNTHETIC_NAMESPACE = "smithy.go.synthetic";
private CodegenUtils() {
}
/**
* Executes a given shell command in a given directory.
*
* @param command The string command to execute, e.g. "go fmt".
* @param directory The directory to run the command in.
* @return Returns the console output of the command.
*/
public static String runCommand(String command, Path directory) {
String[] finalizedCommand;
if (System.getProperty("os.name").toLowerCase().startsWith("windows")) {
finalizedCommand = new String[]{"cmd.exe", "/c", command};
} else {
finalizedCommand = new String[]{"sh", "-c", command};
}
ProcessBuilder processBuilder = new ProcessBuilder(finalizedCommand)
.redirectErrorStream(true)
.directory(directory.toFile());
try {
Process process = processBuilder.start();
List output = new ArrayList<>();
// Capture output for reporting.
try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(
process.getInputStream(), Charset.defaultCharset()))) {
String line;
while ((line = bufferedReader.readLine()) != null) {
LOGGER.finest(line);
output.add(line);
}
}
process.waitFor();
process.destroy();
String joinedOutput = String.join(System.lineSeparator(), output);
if (process.exitValue() != 0) {
throw new CodegenException(String.format(
"Command `%s` failed with output:%n%n%s", command, joinedOutput));
}
return joinedOutput;
} catch (InterruptedException | IOException e) {
throw new CodegenException(e);
}
}
/**
* Gets the name under which the given package will be exported by default.
*
* @param packageName The full package name of the exported package.
* @return The name a the package will be imported under by default.
*/
public static String getDefaultPackageImportName(String packageName) {
if (StringUtils.isBlank(packageName) || !packageName.contains("/")) {
return packageName;
}
return packageName.substring(packageName.lastIndexOf('/') + 1);
}
/**
* Gets the alias to use when referencing the given symbol outside of its namespace.
*
* The default value is the last path component of the symbol's namespace.
*
* @param symbol The symbol whose whose namespace alias should be retrieved.
* @return The alias of the symbol's namespace.
*/
public static String getSymbolNamespaceAlias(Symbol symbol) {
return symbol.getProperty(SymbolUtils.NAMESPACE_ALIAS, String.class)
.filter(StringUtils::isNotBlank)
.orElse(CodegenUtils.getDefaultPackageImportName(symbol.getNamespace()));
}
/**
* Detects if an annotated mediatype indicates JSON contents.
*
* @param mediaType The media type to inspect.
* @return If the media type indicates JSON contents.
*/
public static boolean isJsonMediaType(String mediaType) {
return mediaType.equals("application/json") || mediaType.endsWith("+json");
}
/**
* Get the namespace where synthetic types are generated at runtime.
*
* @return synthetic type namespace
*/
public static String getSyntheticTypeNamespace() {
return CodegenUtils.SYNTHETIC_NAMESPACE;
}
/**
* Get if the passed in shape is decorated as a synthetic clone, but there is no other shape the clone is
* created from.
*
* @param shape the shape to check if its a stubbed synthetic clone without an archetype.
* @return if the shape is synthetic clone, but not based on a specific shape.
*/
public static boolean isStubSynthetic(Shape shape) {
Optional optional = shape.getTrait(Synthetic.class);
if (!optional.isPresent()) {
return false;
}
Synthetic synth = optional.get();
return !synth.getArchetype().isPresent();
}
/**
* Returns the operand decorated with an & if the address of the shape type can be taken.
*
* @param model API model reference
* @param pointableIndex pointable index
* @param shape shape to use
* @param operand value to decorate
* @return updated operand
*/
public static String asAddressIfAddressable(
Model model,
GoPointableIndex pointableIndex,
Shape shape,
String operand
) {
boolean isStruct = shape.getType() == ShapeType.STRUCTURE;
if (shape.isMemberShape()) {
isStruct = model.expectShape(shape.asMemberShape().get().getTarget()).getType() == ShapeType.STRUCTURE;
}
boolean shouldAddress = pointableIndex.isPointable(shape) && isStruct;
return shouldAddress ? "&" + operand : operand;
}
/**
* Returns the operand decorated with an "*" if the shape is dereferencable.
*
* @param pointableIndex knowledge index for if shape is pointable.
* @param shape The shape whose value needs to be read.
* @param operand The value to be read from.
* @return updated operand
*/
public static String getAsValueIfDereferencable(
GoPointableIndex pointableIndex,
Shape shape,
String operand
) {
if (!pointableIndex.isDereferencable(shape)) {
return operand;
}
return '*' + operand;
}
/**
* Returns the operand decorated as a pointer type, without creating double pointer.
*
* @param pointableIndex knowledge index for if shape is pointable.
* @param shape The shape whose value of the type.
* @param operand The value to read.
* @return updated operand
*/
public static String getTypeAsTypePointer(
GoPointableIndex pointableIndex,
Shape shape,
String operand
) {
if (pointableIndex.isPointable(shape)) {
return operand;
}
return '*' + operand;
}
/**
* Get the pointer reference to operand , if symbol is pointable.
* This method can be used by deserializers to get pointer to
* operand.
*
* @param model model for api.
* @param writer The writer dependencies will be added to, if needed.
* @param pointableIndex knowledge index for if shape is pointable.
* @param shape The shape whose value needs to be assigned.
* @param operand The Operand is the value to be assigned to the symbol shape.
* @return The Operand, along with pointer reference if applicable
*/
public static String getAsPointerIfPointable(
Model model,
GoWriter writer,
GoPointableIndex pointableIndex,
Shape shape,
String operand
) {
if (!pointableIndex.isPointable(shape)) {
return operand;
}
if (shape.isMemberShape()) {
shape = model.expectShape(shape.asMemberShape().get().getTarget());
}
String prefix = "";
String suffix = ")";
switch (shape.getType()) {
case STRING:
prefix = "ptr.String(";
break;
case BOOLEAN:
prefix = "ptr.Bool(";
break;
case BYTE:
prefix = "ptr.Int8(";
break;
case SHORT:
prefix = "ptr.Int16(";
break;
case INTEGER:
prefix = "ptr.Int32(";
break;
case LONG:
prefix = "ptr.Int64(";
break;
case FLOAT:
prefix = "ptr.Float32(";
break;
case DOUBLE:
prefix = "ptr.Float64(";
break;
case TIMESTAMP:
prefix = "ptr.Time(";
break;
default:
return '&' + operand;
}
writer.addUseImports(SmithyGoDependency.SMITHY_PTR);
return prefix + operand + suffix;
}
/**
* Returns the shape unpacked as a CollectionShape. Throws and exception if the passed in
* shape is not a list or set.
*
* @param shape the list or set shape.
* @return The unpacked CollectionShape.
*/
public static CollectionShape expectCollectionShape(Shape shape) {
if (shape instanceof CollectionShape) {
return (CollectionShape) (shape);
}
throw new CodegenException("expect shape " + shape.getId() + " to be Collection, was " + shape.getType());
}
/**
* Returns the shape unpacked as a MapShape. Throws and exception if the passed in
* shape is not a map.
*
* @param shape the map shape.
* @return The unpacked MapShape.
*/
public static MapShape expectMapShape(Shape shape) {
if (shape instanceof MapShape) {
return (MapShape) (shape);
}
throw new CodegenException("expect shape " + shape.getId() + " to be Map, was " + shape.getType());
}
/**
* Comparator to sort ShapeMember lists alphabetically, with required members first followed by optional members.
*/
public static final class SortedMembers implements Comparator {
private final SymbolProvider symbolProvider;
/**
* Initializes the SortedMembers.
*
* @param symbolProvider symbol provider used for codegen.
*/
public SortedMembers(SymbolProvider symbolProvider) {
this.symbolProvider = symbolProvider;
}
@Override
public int compare(MemberShape a, MemberShape b) {
// first compare if the members are required or not, which ever member is required should win. If both
// members are required or not required, continue on to alphabetic search.
// If a is required but b isn't return -1 so a is sorted before b
// If b is required but a isn't, return 1 so a is sorted after b
// If both a and b are required or optional, use alphabetic sorting of a and b's member name.
int requiredMember = 0;
if (a.hasTrait(RequiredTrait.class)) {
requiredMember -= 1;
}
if (b.hasTrait(RequiredTrait.class)) {
requiredMember += 1;
}
if (requiredMember != 0) {
return requiredMember;
}
return symbolProvider.toMemberName(a)
.compareTo(symbolProvider.toMemberName(b));
}
}
/**
* Attempts to find the first member by exact name in the containing structure. If the member is not found an
* exception will be thrown.
*
* @param shape structure containing member
* @param name member name
* @return MemberShape if found
*/
public static MemberShape expectMember(StructureShape shape, String name) {
return expectMember(shape, name::equals);
}
/**
* Attempts to find the first member by name using a member name predicate in the containing structure. If the
* member is not found an exception will be thrown.
*
* @param shape structure containing member
* @param memberNamePredicate member name to search for
* @return MemberShape if found
*/
public static MemberShape expectMember(StructureShape shape, Predicate memberNamePredicate) {
return shape.getAllMembers().values().stream()
.filter((p) -> memberNamePredicate.test(p.getMemberName()))
.findFirst()
.orElseThrow(() -> new CodegenException("did not find member in structure shape, " + shape.getId()));
}
/**
* Attempts to get the title of the API's service from the model. If unalbe to get the title the fallback value
* will be returned instead.
*
* @param shape service shape
* @param fallback string to return if service does not have a title
* @return title of service
*/
public static String getServiceTitle(ServiceShape shape, String fallback) {
return shape.getTrait(TitleTrait.class).map(TitleTrait::getValue).orElse(fallback);
}
/**
* isNumber returns if the shape is a number shape.
*
* @param shape shape to check
* @return true if is a number shape.
*/
public static boolean isNumber(Shape shape) {
switch (shape.getType()) {
case BYTE:
case SHORT:
case INTEGER:
case INT_ENUM:
case LONG:
case FLOAT:
case DOUBLE:
return true;
default:
return false;
}
}
}
CodegenVisitor.java 0000664 0000000 0000000 00000041416 15102203672 0035262 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.ServiceLoader;
import java.util.Set;
import java.util.TreeSet;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import software.amazon.smithy.build.FileManifest;
import software.amazon.smithy.build.PluginContext;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolDependency;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoSettings.ArtifactType;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.ServiceIndex;
import software.amazon.smithy.model.knowledge.TopDownIndex;
import software.amazon.smithy.model.neighbor.Walker;
import software.amazon.smithy.model.shapes.IntEnumShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ShapeVisitor;
import software.amazon.smithy.model.shapes.StringShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.model.transform.ModelTransformer;
import software.amazon.smithy.utils.OptionalUtils;
import software.amazon.smithy.utils.SmithyInternalApi;
/**
* Orchestrates Go client generation.
*/
@SmithyInternalApi
final class CodegenVisitor extends ShapeVisitor.Default {
private static final Logger LOGGER = Logger.getLogger(CodegenVisitor.class.getName());
private final GoSettings settings;
private final Model model;
private final Model modelWithoutTraitShapes;
private final ServiceShape service;
private final FileManifest fileManifest;
private final SymbolProvider symbolProvider;
private final GoDelegator writers;
private final List integrations = new ArrayList<>();
private final ProtocolGenerator protocolGenerator;
private final ApplicationProtocol applicationProtocol;
private final List runtimePlugins = new ArrayList<>();
private final ProtocolDocumentGenerator protocolDocumentGenerator;
private final EventStreamGenerator eventStreamGenerator;
private final GoCodegenContext ctx;
CodegenVisitor(PluginContext context) {
// Load all integrations.
ClassLoader loader = context.getPluginClassLoader().orElse(getClass().getClassLoader());
LOGGER.info("Attempting to discover GoIntegration from the classpath...");
ServiceLoader.load(GoIntegration.class, loader)
.forEach(integration -> {
if (integration.getArtifactType().equals(ArtifactType.CLIENT)) {
LOGGER.info(() -> "Adding GoIntegration: " + integration.getClass().getName());
integrations.add(integration);
}
});
integrations.sort(Comparator.comparingInt(GoIntegration::getOrder));
settings = GoSettings.from(context.getSettings());
fileManifest = context.getFileManifest();
Model resolvedModel = context.getModel();
var modelTransformer = ModelTransformer.create();
/*
* smithy 1.23.0 added support for mixins. This transform flattens and applies
* the mixins
* and remove them from the model
*/
resolvedModel = modelTransformer.flattenAndRemoveMixins(resolvedModel);
// Add unique operation input/output shapes
resolvedModel = AddOperationShapes.execute(resolvedModel, settings.getService());
/*
* smithy 1.12.0 added support for binding common errors to the service shape
* this transform copies these common errors to the operations
*/
resolvedModel = modelTransformer.copyServiceErrorsToOperations(resolvedModel,
settings.getService(resolvedModel));
LOGGER.info(() -> "Preprocessing smithy model");
for (GoIntegration goIntegration : integrations) {
resolvedModel = goIntegration.preprocessModel(resolvedModel, settings);
}
model = resolvedModel;
// process final model
integrations.forEach(integration -> {
integration.processFinalizedModel(settings, model);
});
// fetch runtime plugins
integrations.forEach(integration -> {
integration.getClientPlugins().forEach(runtimePlugin -> {
LOGGER.info(() -> "Adding Go runtime plugin: " + runtimePlugin);
runtimePlugins.add(runtimePlugin);
});
});
modelWithoutTraitShapes = modelTransformer.getModelWithoutTraitShapes(model);
service = settings.getService(model);
LOGGER.info(() -> "Generating Go client for service " + service.getId());
SymbolProvider resolvedProvider = GoCodegenPlugin.createSymbolProvider(model, settings);
for (GoIntegration integration : integrations) {
resolvedProvider = integration.decorateSymbolProvider(settings, model, resolvedProvider);
}
symbolProvider = resolvedProvider;
protocolGenerator = resolveProtocolGenerator(integrations, model, service, settings);
applicationProtocol = protocolGenerator == null
? ApplicationProtocol.createDefaultHttpApplicationProtocol()
: protocolGenerator.getApplicationProtocol();
writers = new GoDelegator(fileManifest, symbolProvider);
protocolDocumentGenerator = new ProtocolDocumentGenerator(settings, model, writers);
this.eventStreamGenerator = new EventStreamGenerator(settings, model, writers, symbolProvider, service);
this.ctx = new GoCodegenContext(model, settings, symbolProvider, fileManifest, writers, integrations);
}
private static ProtocolGenerator resolveProtocolGenerator(
Collection integrations,
Model model,
ServiceShape service,
GoSettings settings) {
// Collect all the supported protocol generators.
Map generators = new HashMap<>();
for (GoIntegration integration : integrations) {
for (ProtocolGenerator generator : integration.getProtocolGenerators()) {
generators.put(generator.getProtocol(), generator);
}
}
ServiceIndex serviceIndex = ServiceIndex.of(model);
ShapeId protocolTrait;
try {
protocolTrait = settings.resolveServiceProtocol(serviceIndex, service, generators.keySet());
settings.setProtocol(protocolTrait);
} catch (UnresolvableProtocolException e) {
LOGGER.warning("Unable to find a protocol generator for " + service.getId() + ": " + e.getMessage());
protocolTrait = null;
}
return protocolTrait != null ? generators.get(protocolTrait) : null;
}
void execute() {
// Generate models that are connected to the service being generated.
LOGGER.fine("Walking shapes from " + service.getId() + " to find shapes to generate");
Set serviceShapes = new TreeSet<>(new Walker(modelWithoutTraitShapes).walkShapes(service));
for (Shape shape : serviceShapes) {
shape.accept(this);
}
// Generate any required types and functions need to support protocol documents.
protocolDocumentGenerator.generateDocumentSupport();
// Generate a struct to handle unknown tags in unions
List unions = serviceShapes.stream()
.map(Shape::asUnionShape)
.flatMap(OptionalUtils::stream)
.collect(Collectors.toList());
if (!unions.isEmpty()) {
writers.useShapeWriter(unions.get(0), writer -> {
UnionGenerator.generateUnknownUnion(writer, unions, symbolProvider);
});
}
for (GoIntegration integration : integrations) {
integration.writeAdditionalFiles(settings, model, symbolProvider, writers::useFileWriter);
integration.writeAdditionalFiles(settings, model, symbolProvider, writers);
integration.writeAdditionalFiles(ctx);
}
eventStreamGenerator.generateEventStreamInterfaces();
TopDownIndex.of(model).getContainedOperations(service)
.forEach(eventStreamGenerator::generateOperationEventStreamStructure);
if (protocolGenerator != null) {
LOGGER.info("Generating serde for protocol " + protocolGenerator.getProtocol() + " on " + service.getId());
ProtocolGenerator.GenerationContext.Builder contextBuilder = ProtocolGenerator.GenerationContext.builder()
.protocolName(protocolGenerator.getProtocolName())
.integrations(integrations)
.model(model)
.service(service)
.settings(settings)
.symbolProvider(symbolProvider)
.delegator(writers);
LOGGER.info("Generating serde for protocol " + protocolGenerator.getProtocol()
+ " on " + service.getId());
writers.useFileWriter("serializers.go", settings.getModuleName(), writer -> {
ProtocolGenerator.GenerationContext context = contextBuilder.writer(writer).build();
protocolGenerator.generateRequestSerializers(context);
protocolGenerator.generateSharedSerializerComponents(context);
});
writers.useFileWriter("deserializers.go", settings.getModuleName(), writer -> {
ProtocolGenerator.GenerationContext context = contextBuilder.writer(writer).build();
protocolGenerator.generateResponseDeserializers(context);
protocolGenerator.generateSharedDeserializerComponents(context);
});
if (eventStreamGenerator.hasEventStreamOperations()) {
eventStreamGenerator.writeEventStreamImplementation(writer -> {
ProtocolGenerator.GenerationContext context = contextBuilder.writer(writer).build();
protocolGenerator.generateEventStreamComponents(context);
});
}
writers.useFileWriter("endpoints.go", settings.getModuleName(), writer -> {
ProtocolGenerator.GenerationContext context = contextBuilder.writer(writer).build();
protocolGenerator.generateEndpointResolution(context);
});
writers.useFileWriter("auth.go", settings.getModuleName(), writer -> {
ProtocolGenerator.GenerationContext context = contextBuilder.writer(writer).build();
protocolGenerator.generateAuth(context);
});
writers.useFileWriter("endpoints_test.go", settings.getModuleName(), writer -> {
ProtocolGenerator.GenerationContext context = contextBuilder.writer(writer).build();
protocolGenerator.generateEndpointResolutionTests(context);
});
LOGGER.info("Generating protocol " + protocolGenerator.getProtocol()
+ " unit tests for " + service.getId());
writers.useFileWriter("protocol_test.go", settings.getModuleName(), writer -> {
protocolGenerator.generateProtocolTests(contextBuilder.writer(writer).build());
});
protocolDocumentGenerator.generateInternalDocumentTypes(protocolGenerator, contextBuilder.build());
}
LOGGER.fine("Flushing go writers");
List dependencies = writers.getDependencies();
writers.flushWriters();
GoModuleInfo goModuleInfo = new GoModuleInfo.Builder()
.goDirective(settings.getGoDirective())
.dependencies(dependencies)
.build();
GoModGenerator.writeGoMod(settings, fileManifest, goModuleInfo);
LOGGER.fine("Generating build manifest file");
ManifestWriter.writeManifest(settings, model, fileManifest, goModuleInfo);
}
@Override
protected Void getDefault(Shape shape) {
return null;
}
@Override
public Void structureShape(StructureShape shape) {
if (shape.getId().getNamespace().equals(CodegenUtils.getSyntheticTypeNamespace())) {
return null;
}
Symbol symbol = symbolProvider.toSymbol(shape);
writers.useShapeWriter(shape, writer -> new StructureGenerator(
model, symbolProvider, writer, service, shape, symbol, protocolGenerator).run());
return null;
}
@Override
public Void stringShape(StringShape shape) {
if (shape.hasTrait(EnumTrait.class)) {
writers.useShapeWriter(shape, writer -> new EnumGenerator(symbolProvider, writer, shape).run());
}
return null;
}
@Override
public Void unionShape(UnionShape shape) {
UnionGenerator generator = new UnionGenerator(model, symbolProvider, shape);
writers.useShapeWriter(shape, generator::generateUnion);
writers.useShapeExportedTestWriter(shape, generator::generateUnionExamples);
return null;
}
@Override
public Void serviceShape(ServiceShape shape) {
if (!Objects.equals(service, shape)) {
LOGGER.fine(() -> "Skipping `" + shape.getId() + "` because it is not `" + service.getId() + "`");
return null;
}
var protocol = protocolGenerator != null
? protocolGenerator.getApplicationProtocol()
: ApplicationProtocol.createDefaultHttpApplicationProtocol();
var context = ProtocolGenerator.GenerationContext.builder()
.protocolName(protocol.getName())
.integrations(integrations)
.model(model)
.service(service)
.settings(settings)
.symbolProvider(symbolProvider)
.delegator(writers)
.build();
// Write API client's package doc for the service.
writers.useFileWriter("doc.go", settings.getModuleName(), (writer) -> {
writer.writePackageDocs(String.format(
"Package %s provides the API client, operations, and parameter types for %s.",
CodegenUtils.getDefaultPackageImportName(settings.getModuleName()),
CodegenUtils.getServiceTitle(shape, "the API")));
writer.writePackageDocs("");
writer.writePackageShapeDocs(shape);
});
// Write API client type and utilities.
writers.useShapeWriter(shape, serviceWriter -> {
new ServiceGenerator(settings, model, symbolProvider, serviceWriter, shape, integrations,
runtimePlugins, applicationProtocol).run();
// Generate each operation for the service. We do this here instead of via the
// operation visitor method to
// limit it to the operations bound to the service.
TopDownIndex topDownIndex = model.getKnowledge(TopDownIndex.class);
Set containedOperations = new TreeSet<>(topDownIndex.getContainedOperations(service));
for (OperationShape operation : containedOperations) {
writers.useShapeWriter(operation, operationWriter ->
new OperationGenerator(ctx, operationWriter, operation, protocolGenerator, runtimePlugins)
.run());
}
});
var clientOptions = new ClientOptions(context, protocol);
writers.useFileWriter("options.go", settings.getModuleName(), clientOptions);
return null;
}
@Override
public Void intEnumShape(IntEnumShape shape) {
writers.useShapeWriter(shape, writer -> new IntEnumGenerator(symbolProvider, writer, shape).run());
return null;
}
}
DocumentationConverter.java 0000664 0000000 0000000 00000036340 15102203672 0037037 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.commonmark.node.BlockQuote;
import org.commonmark.node.FencedCodeBlock;
import org.commonmark.node.Heading;
import org.commonmark.node.HtmlBlock;
import org.commonmark.node.ListBlock;
import org.commonmark.node.ThematicBreak;
import org.commonmark.parser.Parser;
import org.commonmark.renderer.html.HtmlRenderer;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.jsoup.nodes.TextNode;
import org.jsoup.safety.Safelist;
import org.jsoup.select.NodeTraversor;
import org.jsoup.select.NodeVisitor;
import software.amazon.smithy.utils.CodeWriter;
import software.amazon.smithy.utils.SetUtils;
import software.amazon.smithy.utils.StringUtils;
/**
* Converts commonmark-formatted documentation into godoc format.
*/
public final class DocumentationConverter {
// godoc only supports text blocks, root-level non-inline code blocks, headers, and links.
// This allowlist strips out anything we can't reasonably convert, vastly simplifying the
// node tree we end up having to crawl through.
private static final Safelist GODOC_ALLOWLIST = new Safelist()
.addTags("code", "pre", "ul", "ol", "li", "a", "br", "h1", "h2", "h3", "h4", "h5", "h6", "p")
.addAttributes("a", "href")
.addProtocols("a", "href", "http", "https");
// Construct a markdown parser that specifically ignores parsing indented code blocks. This
// is because HTML blocks can have really wonky formatting that can be mis-attributed to an
// indented code blocks. We may need to add a configuration option to re-enable this.
private static final Parser MARKDOWN_PARSER = Parser.builder()
.enabledBlockTypes(SetUtils.of(
Heading.class, HtmlBlock.class, ThematicBreak.class, FencedCodeBlock.class,
BlockQuote.class, ListBlock.class))
.build();
private DocumentationConverter() {}
/**
* Converts a commonmark formatted string into a godoc formatted string.
*
* @param docs commonmark formatted documentation
* @return godoc formatted documentation
*/
public static String convert(String docs, int docWrapLength) {
// Smithy's documentation format is commonmark, which can inline html. So here we convert
// to html so we have a single known format to work with.
String htmlDocs = HtmlRenderer.builder().escapeHtml(false).build().render(MARKDOWN_PARSER.parse(docs));
// Strip out tags and attributes we can't reasonably convert to godoc.
htmlDocs = Jsoup.clean(htmlDocs, GODOC_ALLOWLIST);
// Now we parse the html and visit the resultant nodes to render the godoc.
FormattingVisitor formatter = new FormattingVisitor(docWrapLength);
Node body = Jsoup.parse(htmlDocs).body();
NodeTraversor.traverse(formatter, body);
return formatter.toString();
}
private static class FormattingVisitor implements NodeVisitor {
private static final Set TEXT_BLOCK_NODES = SetUtils.of(
"br", "p", "h1", "h2", "h3", "h4", "h5", "h6", "note"
);
private static final Set LIST_BLOCK_NODES = SetUtils.of("ul", "ol");
private static final Set CODE_BLOCK_NODES = SetUtils.of("pre", "code");
private final CodeWriter writer;
// Godoc links are added at the end as `[text]: http://example.com` so keeping a collection to add them later
private final Map links;
private boolean needsListPrefix = false;
private boolean shouldStripPrefixWhitespace = false;
private int docWrapLength;
private int listDepth;
// the last line string written, used to calculate the remaining spaces to reach docWrapLength
// and determine if a split char is needed between it and next string
private String lastLineString;
FormattingVisitor(int docWrapLength) {
writer = new CodeWriter();
writer.trimTrailingSpaces(false);
writer.trimBlankLines();
writer.insertTrailingNewline(false);
this.docWrapLength = docWrapLength;
this.links = new HashMap<>();
this.lastLineString = "";
}
@Override
public void head(Node node, int depth) {
String name = node.nodeName();
if (isTopLevelCodeBlock(node, depth)) {
writer.indent();
}
if (node.nodeName().equals("a")) {
// Logic to format anchors as Go Links https://tip.golang.org/doc/comment#links
Element element = (Element) node;
String text = element.text();
String url = element.absUrl("href");
if (url.isEmpty()) {
// an empty anchor won't have a reference at the end, so just
// output it directly to the output
writer.writeInlineWithNoFormatting(text);
return;
}
String wrappedAnchorText = "[" + text + "]";
writer.writeInlineWithNoFormatting(wrappedAnchorText);
links.put(text, url);
}
Node parentNode = node.parentNode();
if (parentNode != null && parentNode.nodeName().equals("a") && node instanceof TextNode) {
// anchor tags get processed twice: once as anchor tags and another one as
// textNodes. Since this was already processed as anchor, no need to do anything else
return;
}
if (node instanceof TextNode) {
writeText((TextNode) node);
} else if (isTopLevelCodeBlock(node, depth)) {
writeNewline();
writeIndent();
} else if (LIST_BLOCK_NODES.contains(name)) {
listDepth++;
} else if (name.equals("li")) {
// We don't actually write out the list prefix here in case the list element
// starts with one or more text blocks. By deferring writing those out until
// the first bit of actual text, we can ensure that no intermediary newlines
// are kept. It also has the added benefit of eliminating empty list elements.
needsListPrefix = true;
}
}
private void writeText(TextNode node) {
if (node.isBlank()) {
return;
}
// Docs can have valid $ characters that shouldn't run through formatters.
String text = node.text().replace("$", "$$");
if (shouldStripPrefixWhitespace) {
shouldStripPrefixWhitespace = false;
text = StringUtils.stripStart(text, " \t");
}
if (listDepth > 0) {
text = StringUtils.stripStart(text, " \t");
if (needsListPrefix) {
needsListPrefix = false;
text = " - " + text;
writeNewline();
}
writeWrappedText(text, "\n ");
} else {
writeWrappedText(text, "\n");
}
}
private void writeWrappedText(String text, String newLineIndent) {
// check the last line's remaining space to see if test should be
// split to 2 parts to write to current and next line
// note that wrapped text will not contain desired indent at the beginning,
// so indent will be added to the wrapped text when it is written to a new line
// right boundary index of text to be written to the same line exceeding
// neither docWrapLength nor text length
int trailingLineCutoff = Math.min(Math.max(docWrapLength - lastLineString.length(), 0), text.length());
// the index of last space on the left of boundary if exist
int lastSpace = text.substring(0, trailingLineCutoff).lastIndexOf(" ");
// if current line is large enough to put the text, just append complete text to current line
// otherwise, cut out next line string starting from lastSpace index
String appendString = trailingLineCutoff < text.length() ? text.substring(0, lastSpace + 1) : text;
String nextLineString = trailingLineCutoff < text.length() ? text.substring(lastSpace + 1) : "";
if (!appendString.isEmpty()) {
ensureSplit(" ", appendString);
writeInline(appendString);
}
if (!nextLineString.isEmpty()) {
nextLineString = StringUtils.stripStart(newLineIndent, "\n")
+ StringUtils.wrap(nextLineString, docWrapLength, newLineIndent, false);
writeNewline();
writeInline(nextLineString);
}
}
private void ensureSplit(String split, String text) {
if (!text.startsWith(split) && !lastLineString.isEmpty() && !lastLineString.endsWith(split)) {
writeInline(split);
}
}
private void writeNewline() {
// While jsoup will strip out redundant whitespace, it will still leave some. If we
// start a new line then we want to make sure we don't keep any prefixing whitespace.
// need to refresh last line string
shouldStripPrefixWhitespace = true;
writer.write("");
lastLineString = "";
}
private void writeInline(String contents, String... args) {
// write text at the current line, update last line string
String formatText = writer.format(contents, args);
writer.writeInlineWithNoFormatting(formatText);
formatText = lastLineString + formatText;
lastLineString = formatText.substring(formatText.lastIndexOf("\n") + 1);
}
void writeIndent() {
writer.setNewline("").write("").setNewline("\n");
}
private boolean isTopLevelCodeBlock(Node node, int depth) {
// The node must be a code block node
if (!CODE_BLOCK_NODES.contains(node.nodeName())) {
return false;
}
// It must either have no siblings or its siblings must be separate blocks.
if (!allSiblingsAreBlocks(node)) {
return false;
}
// Depth 0 will always be a "body" element, so depth 1 means it's top level.
if (depth == 1) {
return true;
}
// If its depth is 2, it could still be effectively top level if its parent is a p
// node whose siblings are all blocks.
Node parent = node.parent();
return depth == 2 && parent.nodeName().equals("p") && allSiblingsAreBlocks(parent);
}
/**
* Determines whether a given node's siblings are all text blocks, code blocks, or lists.
*
* Siblings that are blank text nodes are skipped.
*
* @param node The node whose siblings should be checked.
* @return true if the node's siblings are blocks, otherwise false.
*/
private boolean allSiblingsAreBlocks(Node node) {
// Find the nearest sibling to the left which is not a blank text node.
Node previous = node.previousSibling();
while (true) {
if (previous instanceof TextNode) {
if (((TextNode) previous).isBlank()) {
previous = previous.previousSibling();
continue;
}
}
break;
}
// Find the nearest sibling to the right which is not a blank text node.
Node next = node.nextSibling();
while (true) {
if (next instanceof TextNode) {
if (((TextNode) next).isBlank()) {
next = next.nextSibling();
continue;
}
}
break;
}
return (previous == null || isBlockNode(previous)) && (next == null || isBlockNode(next));
}
private boolean isBlockNode(Node node) {
String name = node.nodeName();
return TEXT_BLOCK_NODES.contains(name) || LIST_BLOCK_NODES.contains(name)
|| CODE_BLOCK_NODES.contains(name);
}
@Override
public void tail(Node node, int depth) {
String name = node.nodeName();
if (isTopLevelCodeBlock(node, depth)) {
writer.dedent();
}
if (TEXT_BLOCK_NODES.contains(name) || isTopLevelCodeBlock(node, depth)) {
// A single newline is just treated as a line break, but gets
// rendered as the same block.
// Two ensure the text gets treated as a separate text block
writeNewline();
writeNewline();
} else if (LIST_BLOCK_NODES.contains(name)) {
listDepth--;
if (listDepth == 0) {
writeNewline();
}
} else if (name.equals("li")) {
// Clear out the expectation of a list element if the element's body is empty.
needsListPrefix = false;
}
}
@Override
public String toString() {
String result = writer.toString();
if (StringUtils.isBlank(result)) {
return "";
}
// Strip trailing whitespace from every line. We can't use the codewriter for this due to
// not knowing when a line will end, as we typically build them up over many elements.
String[] lines = result.split("\n", -1);
for (int i = 0; i < lines.length; i++) {
lines[i] = StringUtils.stripEnd(lines[i], " \t");
}
result = String.join("\n", lines);
// iterate over every link found and append it at the end
String allLinks = links.entrySet().stream()
.map(link -> formatLink(link))
.collect(Collectors.joining("\n"));
if (!allLinks.isEmpty()) {
result += "\n\n" + allLinks;
}
// Strip out leading and trailing newlines.
return StringUtils.strip(result, "\n");
}
private String formatLink(Map.Entry link) {
String anchor = link.getKey();
String destination = link.getValue();
return "[%s]: %s".formatted(anchor, destination);
}
}
}
EnumGenerator.java 0000664 0000000 0000000 00000011067 15102203672 0035110 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.LinkedHashSet;
import java.util.Locale;
import java.util.Set;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.model.shapes.StringShape;
import software.amazon.smithy.model.traits.EnumDefinition;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.utils.SmithyInternalApi;
import software.amazon.smithy.utils.StringUtils;
/**
* Renders enums and their constants.
*/
@SmithyInternalApi
public final class EnumGenerator implements Runnable {
private static final Logger LOGGER = Logger.getLogger(EnumGenerator.class.getName());
private final SymbolProvider symbolProvider;
private final GoWriter writer;
private final StringShape shape;
public EnumGenerator(SymbolProvider symbolProvider, GoWriter writer, StringShape shape) {
this.symbolProvider = symbolProvider;
this.writer = writer;
this.shape = shape;
}
@Override
public void run() {
Symbol symbol = symbolProvider.toSymbol(shape);
EnumTrait enumTrait = shape.expectTrait(EnumTrait.class);
writer.write("type $L string", symbol.getName()).write("");
// Don't generate constants if there are no explicitly modeled names. We only need to
// look at one, since Smithy validates that if one has a name then they must all have
// a name.
if (enumTrait.getValues().get(0).getName().isPresent()) {
writer.writeDocs(String.format("Enum values for %s", symbol.getName()));
Set constants = new LinkedHashSet<>();
writer.openBlock("const (", ")", () -> {
for (EnumDefinition definition : enumTrait.getValues()) {
StringBuilder labelBuilder = new StringBuilder(symbol.getName());
String name = definition.getName().get();
for (String part : name.split("(?U)[\\W_]")) {
if (part.matches(".*[a-z].*") && part.matches(".*[A-Z].*")) {
// Mixed case names should not be changed other than first letter capitalized.
labelBuilder.append(StringUtils.capitalize(part));
} else {
// For all non-mixed case parts title case first letter, followed by all other lower cased.
labelBuilder.append(StringUtils.capitalize(part.toLowerCase(Locale.US)));
}
}
String label = labelBuilder.toString();
// If camel-casing would cause a conflict, don't camel-case this enum value.
if (constants.contains(label)) {
LOGGER.warning(String.format(
"Multiple enums resolved to the same name, `%s`, using unaltered value for: %s",
label, name));
label = name;
}
constants.add(label);
definition.getDocumentation().ifPresent(writer::writeDocs);
writer.write("$L $L = $S", label, symbol.getName(), definition.getValue());
}
}).write("");
}
writer.writeDocs(String.format("Values returns all known values for %s. Note that this can be expanded in the "
+ "future, and so it is only as up to date as the client.%n%nThe ordering of this slice is not "
+ "guaranteed to be stable across updates.", symbol.getName()));
writer.openBlock("func ($L) Values() []$L {", "}", symbol.getName(), symbol.getName(), () -> {
writer.openBlock("return []$L{", "}", symbol.getName(), () -> {
for (EnumDefinition definition : enumTrait.getValues()) {
writer.write("$S,", definition.getValue());
}
});
});
}
}
EventStreamGenerator.java 0000664 0000000 0000000 00000046556 15102203672 0036454 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Consumer;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.EventStreamIndex;
import software.amazon.smithy.model.knowledge.TopDownIndex;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ToShapeId;
import software.amazon.smithy.utils.StringUtils;
public final class EventStreamGenerator {
public static final String AMZ_CONTENT_TYPE = "application/vnd.amazon.eventstream";
private static final String EVENT_STREAM_FILE = "eventstream.go";
private final GoSettings settings;
private final Model model;
private final GoDelegator writers;
private final ServiceShape serviceShape;
private final EventStreamIndex streamIndex;
private final SymbolProvider symbolProvider;
public EventStreamGenerator(
GoSettings settings,
Model model,
GoDelegator writers,
SymbolProvider symbolProvider,
ServiceShape serviceShape
) {
this.settings = settings;
this.model = model;
this.writers = writers;
this.symbolProvider = symbolProvider;
this.serviceShape = serviceShape;
this.streamIndex = EventStreamIndex.of(this.model);
}
public void generateEventStreamInterfaces() {
if (!hasEventStreamOperations()) {
return;
}
final Set inputEvents = new TreeSet<>();
final Set outputEvents = new TreeSet<>();
TopDownIndex.of(model).getContainedOperations(serviceShape).forEach(operationShape -> {
streamIndex.getInputInfo(operationShape).ifPresent(eventStreamInfo ->
inputEvents.add(eventStreamInfo.getEventStreamMember().getTarget()));
streamIndex.getOutputInfo(operationShape).ifPresent(eventStreamInfo ->
outputEvents.add(eventStreamInfo.getEventStreamMember().getTarget()));
});
Symbol context = SymbolUtils.createValueSymbolBuilder("Context",
SmithyGoDependency.CONTEXT).build();
writers.useFileWriter(EVENT_STREAM_FILE, settings.getModuleName(), writer -> {
inputEvents.forEach(shapeId -> {
Shape shape = model.expectShape(shapeId);
String writerInterfaceName = getEventStreamWriterInterfaceName(serviceShape, shape);
writer.writeDocs(String.format("%s provides the interface for writing events to a stream.",
writerInterfaceName))
.writeDocs("")
.writeDocs("The writer's Close method must allow multiple concurrent calls.");
writer.openBlock("type $L interface {", "}", writerInterfaceName, () -> {
writer.write("Send($T, $T) error", context, symbolProvider.toSymbol(shape));
writer.write("Close() error");
writer.write("Err() error");
});
});
outputEvents.forEach(shapeId -> {
Shape shape = model.expectShape(shapeId);
String readerInterfaceName = getEventStreamReaderInterfaceName(serviceShape, shape);
writer.writeDocs(String.format("%s provides the interface for reading events from a stream.",
readerInterfaceName))
.writeDocs("")
.writeDocs("The writer's Close method must allow multiple concurrent calls.");
writer.openBlock("type $L interface {", "}", readerInterfaceName, () -> {
writer.write("Events() <-chan $T", symbolProvider.toSymbol(shape));
writer.write("Close() error");
writer.write("Err() error");
});
});
});
}
public boolean hasEventStreamOperations() {
return hasEventStreamOperations(model, serviceShape, streamIndex);
}
public static boolean hasEventStreamOperations(Model model, ServiceShape serviceShape) {
EventStreamIndex index = EventStreamIndex.of(model);
return hasEventStreamOperations(model, serviceShape, index);
}
private static boolean hasEventStreamOperations(Model model, ServiceShape serviceShape, EventStreamIndex index) {
return TopDownIndex.of(model).getContainedOperations(serviceShape).stream()
.anyMatch(operationShape -> hasEventStream(model, operationShape, index));
}
public void writeEventStreamImplementation(Consumer goWriterConsumer) {
writers.useFileWriter(EVENT_STREAM_FILE, settings.getModuleName(), goWriterConsumer);
}
public boolean hasEventStream(OperationShape operationShape) {
EventStreamIndex index = EventStreamIndex.of(model);
return hasEventStreamOperations(model, serviceShape, index);
}
public static boolean hasEventStream(Model model, OperationShape operationShape) {
EventStreamIndex index = EventStreamIndex.of(model);
return hasEventStream(model, operationShape, index);
}
private static boolean hasEventStream(Model model, OperationShape operationShape, EventStreamIndex index) {
return index.getInputInfo(operationShape).isPresent() || index.getOutputInfo(operationShape).isPresent();
}
public void generateOperationEventStreamStructure(OperationShape operationShape) {
if (!hasEventStream(model, operationShape)) {
return;
}
writers.useShapeWriter(operationShape, writer -> generateOperationEventStreamStructure(writer, operationShape));
}
private void generateOperationEventStreamStructure(GoWriter writer, OperationShape operationShape) {
var opEventStreamStructure = getEventStreamOperationStructureSymbol(serviceShape, operationShape);
var constructor = getEventStreamOperationStructureConstructor(serviceShape, operationShape);
var inputInfo = streamIndex.getInputInfo(operationShape);
var outputInfo = streamIndex.getOutputInfo(operationShape);
writer.write("""
// $T provides the event stream handling for the $L operation.
//
// For testing and mocking the event stream this type should be initialized via
// the $T constructor function. Using the functional options
// to pass in nested mock behavior.""", opEventStreamStructure, operationShape.getId().getName(),
constructor
);
writer.openBlock("type $T struct {", "}", opEventStreamStructure, () -> {
inputInfo.ifPresent(eventStreamInfo -> {
var eventStreamTarget = eventStreamInfo.getEventStreamTarget();
var writerInterfaceName = getEventStreamWriterInterfaceName(serviceShape, eventStreamTarget);
writer.writeDocs(String.format("""
%s is the EventStream writer for the %s events. This value is
automatically set by the SDK when the API call is made Use this
member when unit testing your code with the SDK to mock out the
EventStream Writer.""",
writerInterfaceName, eventStreamTarget.getId().getName(serviceShape)))
.writeDocs("")
.writeDocs("Must not be nil.")
.write("Writer $L", writerInterfaceName).write("");
});
outputInfo.ifPresent(eventStreamInfo -> {
var eventStreamTarget = eventStreamInfo.getEventStreamTarget();
var readerInterfaceName = getEventStreamReaderInterfaceName(serviceShape, eventStreamTarget);
writer.writeDocs(String.format("""
%s is the EventStream reader for the %s events. This value is
automatically set by the SDK when the API call is made Use this
member when unit testing your code with the SDK to mock out the
EventStream Reader.""",
readerInterfaceName, eventStreamTarget.getId().getName(serviceShape)))
.writeDocs("")
.writeDocs("Must not be nil.")
.write("Reader $L", readerInterfaceName).write("");
});
writer.write("done chan struct{}")
.write("closeOnce $T", SymbolUtils.createValueSymbolBuilder("Once", SmithyGoDependency.SYNC)
.build())
.write("err $P", SymbolUtils.createPointableSymbolBuilder("OnceErr",
SmithyGoDependency.SMITHY_SYNC).build());
}).write("");
writer.write("""
// $T initializes an $T.
// This function should only be used for testing and mocking the $T
// stream within your application.""", constructor, opEventStreamStructure,
opEventStreamStructure);
if (inputInfo.isPresent()) {
writer.writeDocs("");
writer.writeDocs("The Writer member must be set before writing events to the stream.");
}
if (outputInfo.isPresent()) {
writer.writeDocs("");
writer.writeDocs("The Reader member must be set before reading events from the stream.");
}
writer.openBlock("func $T(optFns ...func($P)) $P {", "}", constructor,
opEventStreamStructure, opEventStreamStructure, () -> writer
.openBlock("es := &$L{", "}", opEventStreamStructure, () -> writer
.write("done: make(chan struct{}),")
.write("err: $T(),", SymbolUtils.createValueSymbolBuilder("NewOnceErr",
SmithyGoDependency.SMITHY_SYNC).build()))
.openBlock("for _, fn := range optFns {", "}", () -> writer
.write("fn(es)"))
.write("return es")).write("");
if (inputInfo.isPresent()) {
writer.write("""
// Send writes the event to the stream blocking until the event is written.
// Returns an error if the event was not written.
func (es $P) Send(ctx $P, event $P) error {
return es.Writer.Send(ctx, event)
}
""", opEventStreamStructure, SymbolUtils.createValueSymbolBuilder("Context",
SmithyGoDependency.CONTEXT).build(),
symbolProvider.toSymbol(inputInfo.get().getEventStreamTarget()));
}
if (outputInfo.isPresent()) {
writer.write("""
// Events returns a channel to read events from.
func (es $P) Events() <-chan $P {
return es.Reader.Events()
}
""", opEventStreamStructure, symbolProvider.toSymbol(outputInfo.get().getEventStreamTarget()));
}
writer.write("""
// Close closes the stream. This will also cause the stream to be closed.
// Close must be called when done using the stream API. Not calling Close
// may result in resource leaks.
//
// Will close the underlying EventStream writer and reader, and no more events can be
// sent or received.
func (es $P) Close() error {
es.closeOnce.Do(es.safeClose)
return es.Err()
}
""", opEventStreamStructure);
writer.openBlock("func (es $P) safeClose() {", "}",
opEventStreamStructure, () -> {
writer.write("""
close(es.done)
""");
if (inputInfo.isPresent()) {
var newTicker = SymbolUtils.createValueSymbolBuilder("NewTicker",
SmithyGoDependency.TIME).build();
var second = SymbolUtils.createValueSymbolBuilder("Second",
SmithyGoDependency.TIME).build();
writer.write("""
t := $T($T)
defer t.Stop()
writeCloseDone := make(chan error)
go func() {
if err := es.Writer.Close(); err != nil {
es.err.SetError(err)
}
close(writeCloseDone)
}()
select {
case <-t.C:
case <-writeCloseDone:
}
""", newTicker, second);
}
if (outputInfo.isPresent()) {
writer.write("es.Reader.Close()");
}
}).write("");
writer.writeDocs("""
Err returns any error that occurred while reading or writing EventStream
Events from the service API's response. Returns nil if there were no errors.""");
writer.openBlock("func (es $P) Err() error {", "}",
opEventStreamStructure, () -> {
writer.write("""
if err := es.err.Err(); err != nil {
return err
}
""");
if (inputInfo.isPresent()) {
writer.write("""
if err := es.Writer.Err(); err != nil {
return err
}
""");
}
if (outputInfo.isPresent()) {
writer.write("""
if err := es.Reader.Err(); err != nil {
return err
}
""");
}
writer.write("return nil");
}).write("");
writer.openBlock("func (es $P) waitStreamClose() {", "}", opEventStreamStructure,
() -> {
writer.write("""
type errorSet interface {
ErrorSet() <-chan struct{}
}
""");
if (inputInfo.isPresent()) {
writer.write("""
var inputErrCh <-chan struct{}
if v, ok := es.Writer.(errorSet); ok {
inputErrCh = v.ErrorSet()
}
""");
}
if (outputInfo.isPresent()) {
writer.write("""
var outputErrCh <-chan struct{}
if v, ok := es.Reader.(errorSet); ok {
outputErrCh = v.ErrorSet()
}
var outputClosedCh <-chan struct{}
if v, ok := es.Reader.(interface{ Closed() <-chan struct{} }); ok {
outputClosedCh = v.Closed()
}
""");
}
writer.openBlock("select {", "}", () -> {
writer.write("case <-es.done:");
if (inputInfo.isPresent()) {
writer.write("""
case <-inputErrCh:
es.err.SetError(es.Writer.Err())
es.Close()
""");
}
if (outputInfo.isPresent()) {
writer.write("""
case <-outputErrCh:
es.err.SetError(es.Reader.Err())
es.Close()
case <-outputClosedCh:
if err := es.Reader.Err(); err != nil {
es.err.SetError(es.Reader.Err())
}
es.Close()
""");
}
});
}).write("");
}
public static Symbol getEventStreamOperationStructureConstructor(
ServiceShape serviceShape,
OperationShape operationShape
) {
var symbol = getEventStreamOperationStructureSymbol(serviceShape, operationShape);
return SymbolUtils.createValueSymbolBuilder("New" + symbol.getName()).build();
}
public static Symbol getEventStreamOperationStructureSymbol(
ServiceShape serviceShape,
OperationShape operationShape
) {
String name = StringUtils.capitalize(operationShape.getId().getName(serviceShape));
return SymbolUtils.createPointableSymbolBuilder(name + "EventStream")
.build();
}
public static String getEventStreamWriterInterfaceName(ServiceShape serviceShape, ToShapeId shape) {
String name = StringUtils.capitalize(shape.toShapeId().getName(serviceShape));
return name + "Writer";
}
public static String getEventStreamReaderInterfaceName(ServiceShape serviceShape, ToShapeId shape) {
String name = StringUtils.capitalize(shape.toShapeId().getName(serviceShape));
return name + "Reader";
}
}
GoCodegenContext.java 0000664 0000000 0000000 00000002535 15102203672 0035534 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.List;
import software.amazon.smithy.build.FileManifest;
import software.amazon.smithy.codegen.core.CodegenContext;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.codegen.core.WriterDelegator;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.utils.SmithyInternalApi;
@SmithyInternalApi
public record GoCodegenContext(
Model model,
GoSettings settings,
SymbolProvider symbolProvider,
FileManifest fileManifest,
WriterDelegator writerDelegator,
List integrations
) implements CodegenContext {}
GoCodegenPlugin.java 0000664 0000000 0000000 00000004340 15102203672 0035342 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.logging.Logger;
import software.amazon.smithy.build.PluginContext;
import software.amazon.smithy.build.SmithyBuildPlugin;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.model.Model;
/**
* Plugin to trigger Go code generation.
*/
public final class GoCodegenPlugin implements SmithyBuildPlugin {
private static final Logger LOGGER = Logger.getLogger(GoCodegenPlugin.class.getName());
@Override
public String getName() {
return "go-codegen";
}
@Override
public void execute(PluginContext context) {
String onlyBuild = System.getenv("SMITHY_GO_BUILD_API");
if (onlyBuild != null && !onlyBuild.isEmpty()) {
String targetServiceId = GoSettings.from(context.getSettings()).getService().toString();
boolean found = false;
for (String includeServiceId : onlyBuild.split(",")) {
if (targetServiceId.startsWith(includeServiceId)) {
found = true;
break;
}
}
if (!found) {
LOGGER.info("skipping " + targetServiceId);
return;
}
}
new CodegenVisitor(context).execute();
}
/**
* Creates a Go symbol provider.
*
* @param model The model to generate symbols for.
* @param settings The Gosettings to use to create symbol provider
* @return Returns the created provider.
*/
public static SymbolProvider createSymbolProvider(Model model, GoSettings settings) {
return new SymbolVisitor(model, settings);
}
}
GoDelegator.java 0000664 0000000 0000000 00000005440 15102203672 0034527 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.function.Consumer;
import software.amazon.smithy.build.FileManifest;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.codegen.core.WriterDelegator;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.utils.SmithyInternalApi;
/**
* Manages writers for Go files.Based off of GoWriterDelegator adding support
* for getting shape specific GoWriters.
*/
@SmithyInternalApi
public final class GoDelegator extends WriterDelegator {
private final SymbolProvider symbolProvider;
public GoDelegator(FileManifest fileManifest, SymbolProvider symbolProvider) {
super(fileManifest, symbolProvider, (filename, namespace) -> new GoWriter(namespace));
this.symbolProvider = symbolProvider;
}
/**
* Gets a previously created writer or creates a new one for the Go test file for the associated shape.
*
* @param shape Shape to create the writer for.
* @param writerConsumer Consumer that accepts and works with the file.
*/
public void useShapeTestWriter(Shape shape, Consumer writerConsumer) {
var symbol = symbolProvider.toSymbol(shape);
var filename = symbol.getDefinitionFile();
var testFilename = new StringBuilder(filename)
.insert(filename.lastIndexOf(".go"), "_test")
.toString();
useFileWriter(testFilename, symbol.getNamespace(), writerConsumer);
}
/**
* Gets a previously created writer or creates a new one for the Go public package test file for the associated
* shape.
*
* @param shape Shape to create the writer for.
* @param writerConsumer Consumer that accepts and works with the file.
*/
public void useShapeExportedTestWriter(Shape shape, Consumer writerConsumer) {
var symbol = symbolProvider.toSymbol(shape);
var filename = symbol.getDefinitionFile();
var testFilename = new StringBuilder(filename)
.insert(filename.lastIndexOf(".go"), "_exported_test")
.toString();
useFileWriter(testFilename, symbol.getNamespace() + "_test", writerConsumer);
}
}
GoDependency.java 0000664 0000000 0000000 00000033547 15102203672 0034710 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolDependency;
import software.amazon.smithy.codegen.core.SymbolDependencyContainer;
import software.amazon.smithy.utils.SetUtils;
import software.amazon.smithy.utils.SmithyBuilder;
/**
*
*/
public final class GoDependency implements SymbolDependencyContainer, Comparable {
private final Type type;
private final String sourcePath;
private final String importPath;
private final String alias;
private final String version;
private final Set dependencies;
private final SymbolDependency symbolDependency;
private GoDependency(Builder builder) {
this.type = SmithyBuilder.requiredState("type", builder.type);
this.sourcePath = !this.type.equals(Type.STANDARD_LIBRARY)
? SmithyBuilder.requiredState("sourcePath", builder.sourcePath) : "";
this.importPath = SmithyBuilder.requiredState("importPath", builder.importPath);
this.alias = builder.alias;
this.version = SmithyBuilder.requiredState("version", builder.version);
this.dependencies = builder.dependencies;
this.symbolDependency = SymbolDependency.builder()
.dependencyType(this.type.toString())
.packageName(this.sourcePath)
.version(this.version)
.build();
}
/**
* Given two {@link SymbolDependency} referring to the same package, return the minimum dependency version using
* minimum version selection. The version strings must be semver compatible.
*
* @param dx the first dependency
* @param dy the second dependency
* @return the minimum dependency
*/
public static SymbolDependency mergeByMinimumVersionSelection(SymbolDependency dx, SymbolDependency dy) {
SemanticVersion sx = SemanticVersion.parseVersion(dx.getVersion());
SemanticVersion sy = SemanticVersion.parseVersion(dy.getVersion());
// This *shouldn't* happen in Go since the Go module import path must end with the major version component.
// Exception is the case where the major version is 0 or 1.
if (sx.getMajor() != sy.getMajor() && !(sx.getMajor() == 0 || sy.getMajor() == 0)) {
throw new CodegenException(String.format("Dependency %s has conflicting major versions",
dx.getPackageName()));
}
int cmp = sx.compareTo(sy);
if (cmp < 0) {
return dy;
} else if (cmp > 0) {
return dx;
}
return dx;
}
/**
* Get the the set of {@link GoDependency} required by this dependency.
*
* @return the set of dependencies
*/
public Set getGoDependencies() {
return this.dependencies;
}
/**
* Get the symbol dependency representing the dependency.
*
* @return the symbol dependency
*/
public SymbolDependency getSymbolDependency() {
return symbolDependency;
}
/**
* Get the type of dependency.
*
* @return the dependency type
*/
public Type getType() {
return type;
}
/**
* Get the source code path of the dependency.
*
* @return the dependency source code path
*/
public String getSourcePath() {
return sourcePath;
}
/**
* Get the import path of the dependency.
*
* @return the import path of the dependency
*/
public String getImportPath() {
return importPath;
}
/**
* Get the alias of the module to use.
*
* @return the alias
*/
public String getAlias() {
return alias;
}
/**
* Get the version of the dependency.
*
* @return the version
*/
public String getVersion() {
return version;
}
/**
* Creates a Symbol for a name exported by this package.
* @param name The name.
* @return The symbol.
*/
public Symbol valueSymbol(String name) {
return SymbolUtils.createValueSymbolBuilder(name, this).build();
}
/**
* Creates a Symbol for a `const` exported by this package.
* @param name The name.
* @return The symbol.
*/
public Symbol constSymbol(String name) {
return SymbolUtils.createValueSymbolBuilder(name, this).build();
}
/**
* Creates a Symbol for a `func` exported by this package.
* @param name The name.
* @return The symbol.
*/
public Symbol func(String name) {
return SymbolUtils.createValueSymbolBuilder(name, this).build();
}
/**
* Creates a Symbol for a `struct` exported by this package.
* @param name The name.
* @return The symbol.
*/
public Symbol struct(String name) {
return SymbolUtils.createPointableSymbolBuilder(name, this).build();
}
/**
* Creates a Symbol for a `Value` exported by this package.
* @param name The name.
* @return The symbol.
*/
public Symbol interfaceSymbol(String name) {
return SymbolUtils.createValueSymbolBuilder(name, this).build();
}
/**
* Creates a pointable Symbol for a name exported by this package.
* @param name The name.
* @return The symbol.
*/
public Symbol pointableSymbol(String name) {
return SymbolUtils.createPointableSymbolBuilder(name, this).build();
}
@Override
public List getDependencies() {
Set symbolDependencySet = new TreeSet<>(SetUtils.of(getSymbolDependency()));
symbolDependencySet.addAll(resolveDependencies(getGoDependencies(), new TreeSet<>(SetUtils.of(this))));
return new ArrayList<>(symbolDependencySet);
}
private Set resolveDependencies(Set goDependencies, Set processed) {
Set symbolDependencies = new TreeSet<>();
if (goDependencies.size() == 0) {
return symbolDependencies;
}
Set dependenciesToResolve = new TreeSet<>();
for (GoDependency dependency : goDependencies) {
if (processed.contains(dependency)) {
continue;
}
processed.add(dependency);
symbolDependencies.add(dependency.getSymbolDependency());
dependenciesToResolve.addAll(dependency.getGoDependencies());
}
symbolDependencies.addAll(resolveDependencies(dependenciesToResolve, processed));
return symbolDependencies;
}
public static Builder builder() {
return new Builder();
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (!(o instanceof GoDependency)) {
return false;
}
GoDependency other = (GoDependency) o;
return this.type.equals(other.type) && this.sourcePath.equals(other.sourcePath)
&& this.importPath.equals(other.importPath) && this.alias.equals(other.alias)
&& this.version.equals(other.version) && this.dependencies.equals(other.dependencies);
}
@Override
public int hashCode() {
return Objects.hash(type, sourcePath, importPath, alias, version, dependencies);
}
@Override
public int compareTo(GoDependency o) {
if (equals(o)) {
return 0;
}
int importPathCompare = importPath.compareTo(o.importPath);
if (importPathCompare != 0) {
return importPathCompare;
}
if (alias != null) {
int aliasCompare = alias.compareTo(o.alias);
if (aliasCompare != 0) {
return aliasCompare;
}
}
return version.compareTo(o.version);
}
/**
* Represents a dependency type.
*/
public enum Type {
STANDARD_LIBRARY, DEPENDENCY;
@Override
public String toString() {
switch (this) {
case STANDARD_LIBRARY:
return "stdlib";
case DEPENDENCY:
return "dependency";
default:
return "unknown";
}
}
}
/**
* Get {@link GoDependency} representing the provided module description.
*
* @param sourcePath the root source path for the given code
* @param importPath the import path of the package
* @param version the version of source module
* @param alias a default alias to use when importing the package, can be null
* @return the dependency
*/
public static GoDependency moduleDependency(String sourcePath, String importPath, String version, String alias) {
GoDependency.Builder builder = GoDependency.builder()
.type(GoDependency.Type.DEPENDENCY)
.sourcePath(sourcePath)
.importPath(importPath)
.version(version);
if (alias != null) {
builder.alias(alias);
}
return builder.build();
}
/**
* Get {@link GoDependency} representing the standard library import description.
*
* @param importPath the import path of the package
* @param version the version of source module
* @return the dependency
*/
public static GoDependency standardLibraryDependency(String importPath, String version) {
return GoDependency.builder()
.type(GoDependency.Type.STANDARD_LIBRARY)
.importPath(importPath)
.version(version)
.build();
}
/**
* Get {@link GoDependency} representing the standard library import description.
*
* @param importPath the import path of the package
* @param version the version of source module
* @param alias the alias for stdlib dependency
* @return the dependency
*/
public static GoDependency standardLibraryDependency(String importPath, String version, String alias) {
GoDependency.Builder builder = GoDependency.builder()
.type(GoDependency.Type.STANDARD_LIBRARY)
.importPath(importPath)
.version(version);
if (alias != null) {
builder.alias(alias);
}
return builder.build();
}
/**
* Builder for {@link GoDependency}.
*/
public static final class Builder implements SmithyBuilder {
private Type type;
private String sourcePath;
private String importPath;
private String alias;
private String version;
private final Set dependencies = new TreeSet<>();
private Builder() {
}
/**
* Set the dependency type.
*
* @param type dependency type
* @return the builder
*/
public Builder type(Type type) {
this.type = type;
return this;
}
/**
* Set the source path.
*
* @param sourcePath the source path root
* @return the builder
*/
public Builder sourcePath(String sourcePath) {
this.sourcePath = sourcePath;
return this;
}
/**
* Set the import path.
*
* @param importPath the import path
* @return the builder
*/
public Builder importPath(String importPath) {
this.importPath = importPath;
return this;
}
/**
* Set the dependency alias.
*
* @param alias the alias
* @return the builder
*/
public Builder alias(String alias) {
this.alias = alias;
return this;
}
/**
* Set the dependency version.
*
* @param version the version
* @return the builder
*/
public Builder version(String version) {
this.version = version;
return this;
}
/**
* Set the collection of {@link GoDependency} required by this dependency.
*
* @param dependencies a collection of dependencies
* @return the builder
*/
public Builder dependencies(Collection dependencies) {
this.dependencies.clear();
this.dependencies.addAll(dependencies);
return this;
}
/**
* Add a dependency on another {@link GoDependency}.
*
* @param dependency the dependency
* @return the builder
*/
public Builder addDependency(GoDependency dependency) {
this.dependencies.add(dependency);
return this;
}
/**
* Remove a dependency on another {@link GoDependency}.
*
* @param dependency the dependency
* @return the builder
*/
public Builder removeDependency(GoDependency dependency) {
this.dependencies.remove(dependency);
return this;
}
@Override
public GoDependency build() {
return new GoDependency(this);
}
}
}
GoEventStreamIndex.java 0000664 0000000 0000000 00000011560 15102203672 0036046 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.EventStreamIndex;
import software.amazon.smithy.model.knowledge.EventStreamInfo;
import software.amazon.smithy.model.knowledge.KnowledgeIndex;
import software.amazon.smithy.model.knowledge.TopDownIndex;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ToShapeId;
/**
* Provides a knowledge index about event streams and their corresponding usage in operations.
*/
public class GoEventStreamIndex implements KnowledgeIndex {
final Map>> inputEventStreams = new HashMap<>();
final Map>> outputEventStreams = new HashMap<>();
public GoEventStreamIndex(Model model) {
EventStreamIndex eventStreamIndex = EventStreamIndex.of(model);
for (ServiceShape serviceShape : model.getServiceShapes()) {
final Map> serviceInputStreams = new HashMap<>();
final Map> serviceOutputStreams = new HashMap<>();
TopDownIndex.of(model).getContainedOperations(serviceShape).forEach(operationShape -> {
eventStreamIndex.getInputInfo(operationShape).ifPresent(eventStreamInfo -> {
ShapeId eventStreamTargetId = eventStreamInfo.getEventStreamTarget().getId();
if (serviceInputStreams.containsKey(eventStreamTargetId)) {
serviceInputStreams.get(eventStreamTargetId).add(eventStreamInfo);
} else {
TreeSet infos = new TreeSet<>(
Comparator.comparing(EventStreamInfo::getOperation));
infos.add(eventStreamInfo);
serviceInputStreams.put(eventStreamTargetId, infos);
}
});
eventStreamIndex.getOutputInfo(operationShape).ifPresent(eventStreamInfo -> {
ShapeId eventStreamTargetId = eventStreamInfo.getEventStreamTarget().getId();
if (serviceOutputStreams.containsKey(eventStreamTargetId)) {
serviceOutputStreams.get(eventStreamTargetId).add(eventStreamInfo);
} else {
TreeSet infos = new TreeSet<>(
Comparator.comparing(EventStreamInfo::getOperation));
infos.add(eventStreamInfo);
serviceOutputStreams.put(eventStreamTargetId, infos);
}
});
});
if (!serviceInputStreams.isEmpty()) {
inputEventStreams.put(serviceShape.getId(), serviceInputStreams);
}
if (!serviceOutputStreams.isEmpty()) {
outputEventStreams.put(serviceShape.getId(), serviceOutputStreams);
}
}
}
/**
* Get the input event streams and their usages in operations for the provided service.
*
* @param service the service shape
* @return the map of event stream unions to their corresponding event infos
*/
public Optional>> getInputEventStreams(ToShapeId service) {
return Optional.ofNullable(inputEventStreams.get(service.toShapeId()));
}
/**
* Get the output event streams and their usages in operations for the provided service.
*
* @param service the service shape
* @return the map of event stream unions to their corresponding event infos
*/
public Optional>> getOutputEventStreams(ToShapeId service) {
return Optional.ofNullable(outputEventStreams.get(service.toShapeId()));
}
/**
* Returns a {@link GoEventStreamIndex} for the given model.
*
* @param model the model
* @return the knowledge index
*/
public static GoEventStreamIndex of(Model model) {
return model.getKnowledge(GoEventStreamIndex.class, GoEventStreamIndex::new);
}
}
GoJmespathExpressionGenerator.java 0000664 0000000 0000000 00000052545 15102203672 0040333 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import static software.amazon.smithy.go.codegen.GoWriter.emptyGoTemplate;
import static software.amazon.smithy.go.codegen.GoWriter.goTemplate;
import static software.amazon.smithy.go.codegen.SymbolUtils.isNilable;
import static software.amazon.smithy.go.codegen.SymbolUtils.isPointable;
import static software.amazon.smithy.go.codegen.SymbolUtils.sliceOf;
import static software.amazon.smithy.go.codegen.util.ShapeUtil.BOOL_SHAPE;
import static software.amazon.smithy.go.codegen.util.ShapeUtil.INT_SHAPE;
import static software.amazon.smithy.go.codegen.util.ShapeUtil.STRING_SHAPE;
import static software.amazon.smithy.utils.StringUtils.capitalize;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.go.codegen.util.ShapeUtil;
import software.amazon.smithy.jmespath.JmespathExpression;
import software.amazon.smithy.jmespath.ast.AndExpression;
import software.amazon.smithy.jmespath.ast.ComparatorExpression;
import software.amazon.smithy.jmespath.ast.ComparatorType;
import software.amazon.smithy.jmespath.ast.CurrentExpression;
import software.amazon.smithy.jmespath.ast.FieldExpression;
import software.amazon.smithy.jmespath.ast.FilterProjectionExpression;
import software.amazon.smithy.jmespath.ast.FlattenExpression;
import software.amazon.smithy.jmespath.ast.FunctionExpression;
import software.amazon.smithy.jmespath.ast.LiteralExpression;
import software.amazon.smithy.jmespath.ast.MultiSelectListExpression;
import software.amazon.smithy.jmespath.ast.NotExpression;
import software.amazon.smithy.jmespath.ast.ProjectionExpression;
import software.amazon.smithy.jmespath.ast.Subexpression;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.NumberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.StringShape;
import software.amazon.smithy.utils.SmithyInternalApi;
/**
* Traverses a JMESPath expression, producing a series of statements that evaluate the entire expression. The generator
* is shape-aware and the return indicates the underlying shape/symbol being referenced in the final result.
*
* Note that the use of writer.write() here is deliberate, it's easier to structure the code in that way instead of
* trying to recursively compose/organize Writable templates.
*/
@SmithyInternalApi
public class GoJmespathExpressionGenerator {
private final GoCodegenContext ctx;
private final GoWriter writer;
private int idIndex = 0;
// as we traverse an expression, we may produce intermediate "synthetic" lists - e.g. list of string, list of list
// of string, etc.
// we may need to pull the member shapes back out later, but they're not guaranteed to be in the model - so keep a
// shadow map of synthetic -> member to short-circuit the model lookup
private final Map synthetics = new HashMap<>();
public GoJmespathExpressionGenerator(GoCodegenContext ctx, GoWriter writer) {
this.ctx = ctx;
this.writer = writer;
}
public Variable generate(JmespathExpression expr, Variable input) {
return visit(expr, input);
}
private Variable visit(JmespathExpression expr, Variable current) {
if (expr instanceof FunctionExpression tExpr) {
return visitFunction(tExpr, current);
} else if (expr instanceof FieldExpression tExpr) {
return visitField(tExpr, current);
} else if (expr instanceof Subexpression tExpr) {
return visitSub(tExpr, current);
} else if (expr instanceof ProjectionExpression tExpr) {
return visitProjection(tExpr, current);
} else if (expr instanceof FlattenExpression tExpr) {
return visitFlatten(tExpr, current);
} else if (expr instanceof ComparatorExpression tExpr) {
return visitComparator(tExpr, current);
} else if (expr instanceof LiteralExpression tExpr) {
return visitLiteral(tExpr);
} else if (expr instanceof AndExpression tExpr) {
return visitAnd(tExpr, current);
} else if (expr instanceof NotExpression tExpr) {
return visitNot(tExpr, current);
} else if (expr instanceof FilterProjectionExpression tExpr) {
return visitFilterProjection(tExpr, current);
} else if (expr instanceof MultiSelectListExpression tExpr) {
return visitMultiSelectList(tExpr, current);
} else if (expr instanceof CurrentExpression) {
return current;
} else {
throw new CodegenException("unhandled jmespath expression " + expr.getClass().getSimpleName());
}
}
private Variable visitNot(NotExpression expr, Variable current) {
var inner = visit(expr.getExpression(), current);
var ident = nextIdent();
writer.write("$L := !$L", ident, inner.ident);
return new Variable(BOOL_SHAPE, ident, GoUniverseTypes.Bool);
}
private Variable visitMultiSelectList(MultiSelectListExpression expr, Variable current) {
if (expr.getExpressions().isEmpty()) {
throw new CodegenException("multi-select list w/ no expressions");
}
var items = expr.getExpressions().stream()
.map(it -> visit(it, current))
.toList();
var first = items.get(0);
var ident = nextIdent();
writer.write("$L := []$T{}", ident, first.type);
for (var item : items) {
if (isPointable(item.type)) {
writer.write("""
if $2L != nil {
$1L = append($1L, *$2L)
}""", ident, item.ident);
} else {
writer.write("$1L = append($1L, $2L)", ident, item.ident);
}
}
return new Variable(listOf(first.shape), ident, sliceOf(first.type));
}
private Variable visitFilterProjection(FilterProjectionExpression expr, Variable current) {
var unfiltered = visitProjection(new ProjectionExpression(expr.getLeft(), expr.getRight()), current);
if (!(unfiltered.shape instanceof CollectionShape unfilteredCol)) {
throw new CodegenException("projection did not create a list: " + expr);
}
var member = expectMember(unfilteredCol);
var type = ctx.symbolProvider().toSymbol(unfiltered.shape);
var ident = nextIdent();
writer.write("var $L $T", ident, type);
writer.openBlock("for _, v := range $L {", "}", unfiltered.ident, () -> {
var filterResult = visit(expr.getComparison(), new Variable(member, "v", type));
writer.write("""
if $1L {
$2L = append($2L, v)
}""", filterResult.ident, ident);
});
return new Variable(unfiltered.shape, ident, type);
}
private Variable visitAnd(AndExpression expr, Variable current) {
var left = visit(expr.getLeft(), current);
var right = visit(expr.getRight(), current);
var ident = nextIdent();
writer.write("$L := $L && $L", ident, left.ident, right.ident);
return new Variable(BOOL_SHAPE, ident, GoUniverseTypes.Bool);
}
private Variable visitLiteral(LiteralExpression expr) {
var ident = nextIdent();
if (expr.isNumberValue()) {
// FUTURE: recognize floating-point, for now we just use int
writer.write("$L := $L", ident, expr.expectNumberValue().intValue());
return new Variable(INT_SHAPE, ident, GoUniverseTypes.Int);
} else if (expr.isStringValue()) {
writer.write("$L := $S", ident, expr.expectStringValue());
return new Variable(STRING_SHAPE, ident, GoUniverseTypes.String);
} else if (expr.isBooleanValue()) {
writer.write("$L := $L", ident, expr.expectBooleanValue());
return new Variable(STRING_SHAPE, ident, GoUniverseTypes.Bool);
} else {
throw new CodegenException("unhandled literal expression " + expr.getValue());
}
}
private Variable visitComparator(ComparatorExpression expr, Variable current) {
var left = visit(expr.getLeft(), current);
var right = visit(expr.getRight(), current);
String cast;
if (left.shape instanceof StringShape) {
cast = "string";
} else if (left.shape instanceof NumberShape) {
cast = "int64";
} else {
throw new CodegenException("don't know how to compare shape type" + left.shape.getType());
}
var ident = nextIdent();
writer.write(compareVariables(ident, left, right, expr.getComparator(), cast));
return new Variable(BOOL_SHAPE, ident, GoUniverseTypes.Bool);
}
private Variable visitFlatten(FlattenExpression tExpr, Variable current) {
var inner = visit(tExpr.getExpression(), current);
// inner HAS to be a list by spec, otherwise something is wrong
if (!(inner.shape instanceof CollectionShape innerList)) {
throw new CodegenException("projection did not create a list: " + tExpr);
}
// inner expression may not be a list-of-list - if so, we're done, the result is passed up as-is
var innerMember = expectMember(innerList);
if (!(innerMember instanceof CollectionShape)) {
return inner;
}
var innerSymbol = ctx.symbolProvider().toSymbol(innerMember);
var ident = nextIdent();
writer.write("""
var $1L $3P
for _, v := range $2L {
$1L = append($1L, v...)
}""", ident, inner.ident, innerSymbol);
return new Variable(innerMember, ident, innerSymbol);
}
private Variable visitProjection(ProjectionExpression expr, Variable current) {
var left = visit(expr.getLeft(), current);
if (expr.getRight() instanceof CurrentExpression) { // e.g. "Field[]" - the projection is just itself
return left;
}
Shape leftMember;
if (left.shape instanceof CollectionShape col) {
leftMember = expectMember(col);
} else if (left.shape instanceof MapShape map) {
leftMember = expectMember(map);
} else {
// left of projection HAS to be an array/map by spec, otherwise something is wrong
throw new CodegenException("projection did not create a list: " + expr);
}
var leftSymbol = ctx.symbolProvider().toSymbol(leftMember);
// We have to know the element type for the list that we're generating, use a dummy writer to "peek" ahead and
// get the traversal result
var lookahead = new GoJmespathExpressionGenerator(ctx, new GoWriter(""))
.generate(expr.getRight(), new Variable(leftMember, "v", leftSymbol));
var ident = nextIdent();
writer.write("""
var $L []$T
for _, v := range $L {""", ident, ctx.symbolProvider().toSymbol(lookahead.shape), left.ident);
writer.indent();
// projected.shape is the _member_ of the resulting list
var projected = visit(expr.getRight(), new Variable(leftMember, "v", leftSymbol));
if (isPointable(lookahead.type)) { // projections implicitly filter out nil evaluations of RHS...
var deref = lookahead.shape instanceof CollectionShape || lookahead.shape instanceof MapShape
? "" : "*"; // ...but slices/maps do not get dereferenced
writer.write("""
if $1L != nil {
$2L = append($2L, $3L$1L)
}""", projected.ident, ident, deref);
} else {
writer.write("$1L = append($1L, $2L)", ident, projected.ident);
}
writer.dedent();
writer.write("}");
return new Variable(listOf(projected.shape), ident, sliceOf(ctx.symbolProvider().toSymbol(projected.shape)));
}
private Variable visitSub(Subexpression expr, Variable current) {
var left = visit(expr.getLeft(), current);
if (!isNilable(left.type)) {
return visit(expr.getRight(), left);
}
var lookahead = new GoJmespathExpressionGenerator(ctx, new GoWriter(""))
.generate(expr.getRight(), left);
var ident = nextIdent();
writer.write("var $L $P", ident, lookahead.type);
writer.write("if $L != nil {", left.ident);
writer.indent();
var inner = visit(expr.getRight(), left);
writer.write("$L = $L", ident, inner.ident);
writer.dedent();
writer.write("}");
return new Variable(inner.shape, ident, inner.type);
}
private Variable visitField(FieldExpression expr, Variable current) {
var member = current.shape.getMember(expr.getName()).orElseThrow(() ->
new CodegenException("field expression referenced nonexistent member: " + expr.getName()));
var target = ctx.model().expectShape(member.getTarget());
var ident = nextIdent();
writer.write("$L := $L.$L", ident, current.ident, capitalize(expr.getName()));
return new Variable(target, ident, ctx.symbolProvider().toSymbol(member));
}
private Variable visitFunction(FunctionExpression expr, Variable current) {
return switch (expr.name) {
case "keys" -> visitKeysFunction(expr.arguments, current);
case "length" -> visitLengthFunction(expr.arguments, current);
case "contains" -> visitContainsFunction(expr.arguments, current);
default -> throw new CodegenException("unsupported function " + expr.name);
};
}
private Variable visitContainsFunction(List args, Variable current) {
if (args.size() != 2) {
throw new CodegenException("unexpected contains() arg length " + args.size());
}
var list = visit(args.get(0), current);
var item = visit(args.get(1), current);
var ident = nextIdent();
writer.write("""
var $1L bool
for _, v := range $2L {
if v == $3L {
$1L = true
break
}
}""", ident, list.ident, item.ident);
return new Variable(BOOL_SHAPE, ident, GoUniverseTypes.Bool);
}
private Variable visitLengthFunction(List args, Variable current) {
if (args.size() != 1) {
throw new CodegenException("unexpected length() arg length " + args.size());
}
var arg = visit(args.get(0), current);
var ident = nextIdent();
// length() can be used on a string (so also *string) - dereference if required
if (arg.shape instanceof StringShape && isPointable(arg.type)) {
writer.write("""
var _$1L string
if $1L != nil {
_$1L = *$1L
}
$2L := len(_$1L)""", arg.ident, ident);
} else {
writer.write("$L := len($L)", ident, arg.ident);
}
return new Variable(INT_SHAPE, ident, GoUniverseTypes.Int);
}
private Variable visitKeysFunction(List args, Variable current) {
if (args.size() != 1) {
throw new CodegenException("unexpected keys() arg length " + args.size());
}
var arg = visit(args.get(0), current);
++idIndex;
writer.write("""
var v$1L []string
for k := range $2L {
v$1L = append(v$1L, k)
}""", idIndex, arg.ident);
return new Variable(listOf(STRING_SHAPE), "v" + idIndex, sliceOf(GoUniverseTypes.String));
}
private String nextIdent() {
++idIndex;
return "v" + idIndex;
}
private Shape listOf(Shape shape) {
var list = ShapeUtil.listOf(shape);
synthetics.putIfAbsent(list, shape);
return list;
}
private Shape expectMember(CollectionShape shape) {
return synthetics.containsKey(shape)
? synthetics.get(shape)
: ShapeUtil.expectMember(ctx.model(), shape);
}
private Shape expectMember(MapShape shape) {
return synthetics.containsKey(shape)
? synthetics.get(shape)
: ShapeUtil.expectMember(ctx.model(), shape);
}
// helper to generate comparisons from two results, automatically handling any dereferencing in the process
private GoWriter.Writable compareVariables(String ident, Variable left, Variable right, ComparatorType cmp,
String cast) {
var isLPtr = isPointable(left.type);
var isRPtr = isPointable(right.type);
if (!isLPtr && !isRPtr) {
return goTemplate("$1L := $5L($2L) $4L $5L($3L)", ident, left.ident, right.ident, cmp, cast);
}
// undocumented jmespath behavior: null in numeric _ordering_ comparisons coerces to 0
// this means the subsequent nil checks for numerics are moot, but it's either this or branch the codegen even
// further for questionable benefit
var nilCoerceLeft = emptyGoTemplate();
var nilCoerceRight = emptyGoTemplate();
if (isOrderComparator(cmp)) {
if (isLPtr && left.shape instanceof NumberShape) {
nilCoerceLeft = goTemplate("""
if ($1L == nil) {
$1L = new($2T)
*$1L = 0
}""", left.ident, left.type);
}
if (isRPtr && right.shape instanceof NumberShape) {
nilCoerceRight = goTemplate("""
if ($1L == nil) {
$1L = new($2T)
*$1L = 0
}""", right.ident, right.type);
}
}
// also, if they're both pointers, and it's (in)equality, there's an additional true case where both are nil,
// or both are different
var elseCheckPtrs = emptyGoTemplate();
if (isLPtr && isRPtr) {
if (cmp == ComparatorType.EQUAL) {
elseCheckPtrs = goTemplate("else { $L = $L == nil && $L == nil }",
ident, left.ident, right.ident);
} else if (cmp == ComparatorType.NOT_EQUAL) {
elseCheckPtrs = goTemplate("else { $1L = ($2L == nil && $3L != nil) || ($2L != nil && $3L == nil) }",
ident, left.ident, right.ident);
}
}
return goTemplate("""
var $ident:L bool
$nilCoerceLeft:W
$nilCoerceRight:W
if $lif:L $amp:L $rif:L {
$ident:L = $cast:L($lhs:L) $cmp:L $cast:L($rhs:L)
}$elseCheckPtrs:W""",
Map.of(
"ident", ident,
"lif", isLPtr ? left.ident + " != nil" : "",
"rif", isRPtr ? right.ident + " != nil" : "",
"amp", isLPtr && isRPtr ? "&&" : "",
"cmp", cmp,
"lhs", isLPtr ? "*" + left.ident : left.ident,
"rhs", isRPtr ? "*" + right.ident : right.ident,
"cast", cast,
"nilCoerceLeft", nilCoerceLeft,
"nilCoerceRight", nilCoerceRight
),
Map.of(
"elseCheckPtrs", elseCheckPtrs
));
}
private static boolean isOrderComparator(ComparatorType cmp) {
return cmp == ComparatorType.GREATER_THAN || cmp == ComparatorType.LESS_THAN
|| cmp == ComparatorType.GREATER_THAN_EQUAL || cmp == ComparatorType.LESS_THAN_EQUAL;
}
/**
* Represents a variable (input, intermediate, or final output) of a JMESPath traversal.
* @param shape The underlying shape referenced by this variable. For certain jmespath expressions (e.g.
* LiteralExpression) the value here is a synthetic shape and does not necessarily have meaning.
* @param ident The identifier of the variable in the generated traversal.
* @param type The symbol that records the type of the variable. This does NOT necessarily correspond to the result
* of toSymbol(shape) because certain jmespath expressions (such as projections) may affect the type of
* the resulting variable in a way that severs that relationship. The caller MUST use this field to
* determine whether the variable is pointable/nillable.
*/
public record Variable(Shape shape, String ident, Symbol type) {
public Variable(Shape shape, String ident) {
this(shape, ident, null);
}
}
}
GoModGenerator.java 0000664 0000000 0000000 00000005314 15102203672 0035207 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.logging.Logger;
import software.amazon.smithy.build.FileManifest;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.utils.SmithyInternalApi;
/**
* Generates a go.mod file for the project.
*
* See here for more information on the format: https://github.com/golang/go/wiki/Modules#gomod
*/
@SmithyInternalApi
public final class GoModGenerator {
private static final Logger LOGGER = Logger.getLogger(GoModGenerator.class.getName());
private GoModGenerator() {}
public static void writeGoMod(
GoSettings settings,
FileManifest manifest,
GoModuleInfo goModuleInfo
) {
Boolean generateGoMod = settings.getGenerateGoMod();
if (!generateGoMod) {
return;
}
Path goModFile = manifest.getBaseDir().resolve("go.mod");
LOGGER.fine("Generating go.mod file at path " + goModFile.toString());
// `go mod init` will fail if the `go.mod` already exists, so this deletes
// it if it's present in the output. While it's technically possible
// to simply edit the file, it's easier to just start fresh.
if (Files.exists(goModFile)) {
try {
Files.delete(goModFile);
} catch (IOException e) {
throw new CodegenException("Failed to delete existing go.mod file", e);
}
}
manifest.addFile(goModFile);
CodegenUtils.runCommand("go mod init " + settings.getModuleName(), manifest.getBaseDir());
for (Map.Entry dependency : goModuleInfo.getMinimumNonStdLibDependencies().entrySet()) {
CodegenUtils.runCommand(
String.format("go mod edit -require=%s@%s", dependency.getKey(), dependency.getValue()),
manifest.getBaseDir());
}
CodegenUtils.runCommand(
String.format("go mod edit -go=%s", goModuleInfo.getGoDirective()),
manifest.getBaseDir());
}
}
GoModuleInfo.java 0000664 0000000 0000000 00000011175 15102203672 0034664 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import software.amazon.smithy.codegen.core.SymbolDependency;
import software.amazon.smithy.utils.BuilderRef;
import software.amazon.smithy.utils.SmithyBuilder;
public final class GoModuleInfo {
public static final String DEFAULT_GO_DIRECTIVE = "1.23";
private List dependencies;
private List stdLibDependencies;
private List nonStdLibDependencies;
private String goDirective;
private Map minimumNonStdLibDependencies;
private GoModuleInfo(Builder builder) {
goDirective = SmithyBuilder.requiredState("goDirective", builder.goDirective);
dependencies = builder.dependencies.copy();
// Intermediate dependency information
stdLibDependencies = gatherStdLibDependencies();
nonStdLibDependencies = gatherNonStdLibDependencies();
// Module information used by ManifestWriter and GoModGenerator
goDirective = calculateMinimumGoDirective();
minimumNonStdLibDependencies = gatherMinimumNonStdDependencies();
}
public String getGoDirective() {
return goDirective;
}
public Map getMinimumNonStdLibDependencies() {
return minimumNonStdLibDependencies;
}
private String calculateMinimumGoDirective() {
String minimumGoDirective = goDirective;
if (minimumGoDirective.compareTo(DEFAULT_GO_DIRECTIVE) < 0) {
throw new IllegalArgumentException(
"`goDirective` must be greater than or equal to the default go directive ("
+ DEFAULT_GO_DIRECTIVE + "): " + minimumGoDirective);
}
for (SymbolDependency dependency : stdLibDependencies) {
var otherVersion = dependency.getVersion();
if (minimumGoDirective.compareTo(otherVersion) < 0) {
minimumGoDirective = otherVersion;
}
}
return minimumGoDirective;
}
private List gatherStdLibDependencies() {
return filterDependencies(dependency ->
dependency.getDependencyType().equals(GoDependency.Type.STANDARD_LIBRARY.toString()));
}
private List gatherNonStdLibDependencies() {
return filterDependencies(dependency ->
!dependency.getDependencyType().equals(GoDependency.Type.STANDARD_LIBRARY.toString()));
}
private List filterDependencies(
Predicate predicate
) {
List filteredDependencies = new ArrayList<>();
for (SymbolDependency dependency : dependencies) {
if (predicate.test(dependency)) {
filteredDependencies.add(dependency);
}
}
return filteredDependencies;
}
private Map gatherMinimumNonStdDependencies() {
return SymbolDependency.gatherDependencies(nonStdLibDependencies.stream(),
GoDependency::mergeByMinimumVersionSelection).entrySet().stream().flatMap(
entry -> entry.getValue().entrySet().stream()).collect(
Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().getVersion(), (a, b) -> b, TreeMap::new));
}
public static class Builder implements SmithyBuilder {
private String goDirective = DEFAULT_GO_DIRECTIVE;
private final BuilderRef> dependencies = BuilderRef.forList();
public Builder goDirective(String goDirective) {
this.goDirective = goDirective;
return this;
}
public Builder dependencies(List dependencies) {
this.dependencies.clear();
this.dependencies.get().addAll(dependencies);
return this;
}
@Override
public GoModuleInfo build() {
return new GoModuleInfo(this);
}
}
}
GoSettings.java 0000664 0000000 0000000 00000024124 15102203672 0034421 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import software.amazon.smithy.aws.traits.protocols.AwsJson1_0Trait;
import software.amazon.smithy.aws.traits.protocols.AwsJson1_1Trait;
import software.amazon.smithy.aws.traits.protocols.AwsQueryTrait;
import software.amazon.smithy.aws.traits.protocols.Ec2QueryTrait;
import software.amazon.smithy.aws.traits.protocols.RestJson1Trait;
import software.amazon.smithy.aws.traits.protocols.RestXmlTrait;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.ServiceIndex;
import software.amazon.smithy.model.node.ObjectNode;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.protocol.traits.Rpcv2CborTrait;
import software.amazon.smithy.utils.SmithyInternalApi;
/**
* Settings used by {@link GoCodegenPlugin}.
*/
@SmithyInternalApi
public final class GoSettings {
public static final List PROTOCOLS_BY_PRIORITY = List.of(
Rpcv2CborTrait.ID,
AwsJson1_0Trait.ID,
AwsJson1_1Trait.ID,
RestJson1Trait.ID,
RestXmlTrait.ID,
AwsQueryTrait.ID,
Ec2QueryTrait.ID
);
private static final String SERVICE = "service";
private static final String MODULE_NAME = "module";
private static final String MODULE_DESCRIPTION = "moduleDescription";
private static final String MODULE_VERSION = "moduleVersion";
private static final String GENERATE_GO_MOD = "generateGoMod";
private static final String GO_DIRECTIVE = "goDirective";
private ShapeId service;
private String moduleName;
private String moduleDescription = "";
private String moduleVersion;
private Boolean generateGoMod = false;
private String goDirective = GoModuleInfo.DEFAULT_GO_DIRECTIVE;
private ShapeId protocol;
private ArtifactType artifactType;
@SmithyInternalApi
public enum ArtifactType {
CLIENT,
SERVER;
}
/**
* Create a settings object from a configuration object node.
*
* @param config Config object to load.
* @return Returns the extracted settings.
*/
public static GoSettings from(ObjectNode config) {
return from(config, ArtifactType.CLIENT);
}
@SmithyInternalApi
public static GoSettings from(ObjectNode config, ArtifactType artifactType) {
GoSettings settings = new GoSettings();
config.warnIfAdditionalProperties(
Arrays.asList(SERVICE, MODULE_NAME, MODULE_DESCRIPTION, MODULE_VERSION, GENERATE_GO_MOD, GO_DIRECTIVE));
settings.setArtifactType(artifactType);
settings.setService(config.expectStringMember(SERVICE).expectShapeId());
settings.setModuleName(config.expectStringMember(MODULE_NAME).getValue());
settings.setModuleDescription(config.getStringMemberOrDefault(
MODULE_DESCRIPTION, settings.getModuleName() + " client"));
settings.setModuleVersion(config.getStringMemberOrDefault(MODULE_VERSION, null));
settings.setGenerateGoMod(config.getBooleanMemberOrDefault(GENERATE_GO_MOD, false));
settings.setGoDirective(config.getStringMemberOrDefault(GO_DIRECTIVE, GoModuleInfo.DEFAULT_GO_DIRECTIVE));
return settings;
}
/**
* Gets the id of the service that is being generated.
*
* @return Returns the service id.
* @throws NullPointerException if the service has not been set.
*/
public ShapeId getService() {
return Objects.requireNonNull(service, SERVICE + " not set");
}
/**
* Gets the corresponding {@link ServiceShape} from a model.
*
* @param model Model to search for the service shape by ID.
* @return Returns the found {@code Service}.
* @throws NullPointerException if the service has not been set.
* @throws CodegenException if the service is invalid or not found.
*/
public ServiceShape getService(Model model) {
return model
.getShape(getService())
.orElseThrow(() -> new CodegenException("Service shape not found: " + getService()))
.asServiceShape()
.orElseThrow(() -> new CodegenException("Shape is not a Service: " + getService()));
}
/**
* Sets the service to generate.
*
* @param service The service to generate.
*/
public void setService(ShapeId service) {
this.service = Objects.requireNonNull(service);
}
/**
* Gets the required module name for the module that will be generated.
*
* @return Returns the module name.
* @throws NullPointerException if the module name has not been set.
*/
public String getModuleName() {
return Objects.requireNonNull(moduleName, MODULE_NAME + " not set");
}
/**
* Sets the name of the module to generate.
*
* @param moduleName The name of the module to generate.
*/
public void setModuleName(String moduleName) {
this.moduleName = Objects.requireNonNull(moduleName);
}
/**
* Sets the name of the module to generate.
*
* @param moduleName The name of the module to generate.
*/
public void setModule(String moduleName) {
this.moduleName = Objects.requireNonNull(moduleName);
}
/**
* Gets the optional module description for the module that will be generated.
*
* @return Returns the module description.
*/
public String getModuleDescription() {
return moduleDescription;
}
/**
* Sets the description of the module to generate.
*
* @param moduleDescription The description of the module to generate.
*/
public void setModuleDescription(String moduleDescription) {
this.moduleDescription = Objects.requireNonNull(moduleDescription);
}
/**
* Gets the optional module version for the module that will be generated.
*
* @return Returns the module version.
*/
public Optional getModuleVersion() {
return Optional.ofNullable(moduleVersion);
}
/**
* Sets the version of the module to generate.
*
* @param moduleVersion The version of the module to generate.
*/
public void setModuleVersion(String moduleVersion) {
if (moduleVersion != null) {
this.moduleVersion = moduleVersion;
}
}
/**
* Gets the flag for generating go.mod file.
*
* @return Returns if go.mod will be generated (true) or not (false)
*/
public Boolean getGenerateGoMod() {
return generateGoMod;
}
/**
* Sets the flag for generating go.mod file.
*
* @param generateGoMod If go.mod will be generated (true) or not (false)
*/
public void setGenerateGoMod(Boolean generateGoMod) {
this.generateGoMod = Objects.requireNonNull(generateGoMod);
}
/**
* Gets the optional Go directive for the module that will be generated.
*
* @return Returns the Go directive.
*/
public String getGoDirective() {
return goDirective;
}
/**
* Sets the Go directive of the module to generate.
*
* @param goDirective The Go directive of the module to generate.
*/
public void setGoDirective(String goDirective) {
this.goDirective = Objects.requireNonNull(goDirective);
}
/**
* Gets the configured protocol to generate.
*
* @return Returns the configured protocol.
*/
public ShapeId getProtocol() {
return protocol;
}
/**
* Resolves the highest priority protocol from a service shape that is
* supported by the generator.
*
* @param serviceIndex Service index containing the support
* @param service Service to get the protocols from if "protocols" is not set.
* @param supportedProtocolTraits The set of protocol traits supported by the generator.
* @return Returns the resolved protocol name.
* @throws UnresolvableProtocolException if no protocol could be resolved.
*/
public ShapeId resolveServiceProtocol(
ServiceIndex serviceIndex,
ServiceShape service,
Set supportedProtocolTraits) {
if (protocol != null) {
return protocol;
}
Set resolvedProtocols = serviceIndex.getProtocols(service).keySet();
var byPriority = PROTOCOLS_BY_PRIORITY.stream()
.filter(resolvedProtocols::contains)
.toList();
return byPriority.stream()
.filter(supportedProtocolTraits::contains)
.findFirst()
.orElseThrow(() -> new UnresolvableProtocolException(String.format(
"The %s service supports the following unsupported protocols %s. The following protocol "
+ "generators were found on the class path: %s",
service.getId(), resolvedProtocols, supportedProtocolTraits)));
}
/**
* Sets the protocol to generate.
*
* @param protocol Protocols to generate.
*/
public void setProtocol(ShapeId protocol) {
this.protocol = Objects.requireNonNull(protocol);
}
@SmithyInternalApi
public ArtifactType getArtifactType() {
return artifactType;
}
@SmithyInternalApi
public void setArtifactType(ArtifactType artifactType) {
this.artifactType = artifactType;
}
}
GoStackStepMiddlewareGenerator.java 0000664 0000000 0000000 00000040305 15102203672 0040366 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import static software.amazon.smithy.go.codegen.GoWriter.goTemplate;
import java.util.function.BiConsumer;
import software.amazon.smithy.codegen.core.Symbol;
/**
* Helper for generating stack step middleware.
*/
public final class GoStackStepMiddlewareGenerator {
private static final Symbol CONTEXT_TYPE = SymbolUtils.createValueSymbolBuilder(
"Context", SmithyGoDependency.CONTEXT).build();
private static final Symbol METADATA_TYPE = SymbolUtils.createValueSymbolBuilder(
"Metadata", SmithyGoDependency.SMITHY_MIDDLEWARE).build();
private final Symbol middlewareSymbol;
private final MiddlewareIdentifier middlewareId;
private final String handleMethodName;
private final Symbol inputType;
private final Symbol outputType;
private final Symbol handlerType;
/**
* Creates a new middleware generator with the given builder definition.
*
* @param builder the builder to create the generator with.
*/
public GoStackStepMiddlewareGenerator(Builder builder) {
this.middlewareSymbol = SymbolUtils.createPointableSymbolBuilder(builder.name).build();
this.middlewareId = builder.id;
this.handleMethodName = builder.handleMethodName;
this.inputType = builder.inputType;
this.outputType = builder.outputType;
this.handlerType = builder.handlerType;
}
/**
* Create a new InitializeStep middleware generator with the provided type name.
*
* @param name is the type name to identify the middleware.
* @param id the unique ID for the middleware.
* @return the middleware generator.
*/
public static GoStackStepMiddlewareGenerator createInitializeStepMiddleware(String name, MiddlewareIdentifier id) {
return createMiddleware(name,
id,
"HandleInitialize",
SymbolUtils.createValueSymbolBuilder("InitializeInput", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("InitializeOutput", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("InitializeHandler", SmithyGoDependency.SMITHY_MIDDLEWARE)
.build());
}
/**
* Create an inline Initialize func.
*
* @param body is the function body.
* @return the generated middleware func.
*/
public static GoWriter.Writable generateInitializeMiddlewareFunc(GoWriter.Writable body) {
return goTemplate("""
func(ctx $T, in $T, next $T) (
out $T, metadata $T, err error,
) {
$W
}
""",
GoStdlibTypes.Context.Context,
SmithyGoTypes.Middleware.InitializeInput,
SmithyGoTypes.Middleware.InitializeHandler,
SmithyGoTypes.Middleware.InitializeOutput,
SmithyGoTypes.Middleware.Metadata,
body);
}
/**
* Create a new BuildStep middleware generator with the provided type name.
*
* @param name is the type name to identify the middleware.
* @param id the unique ID for the middleware.
* @return the middleware generator.
*/
public static GoStackStepMiddlewareGenerator createBuildStepMiddleware(String name, MiddlewareIdentifier id) {
return createMiddleware(name,
id,
"HandleBuild",
SymbolUtils.createValueSymbolBuilder("BuildInput", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("BuildOutput", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("BuildHandler", SmithyGoDependency.SMITHY_MIDDLEWARE).build());
}
/**
* Create a new SerializeStep middleware generator with the provided type name.
*
* @param name is the type name to identify the middleware.
* @param id the unique ID for the middleware.
* @return the middleware generator.
*/
public static GoStackStepMiddlewareGenerator createSerializeStepMiddleware(String name, MiddlewareIdentifier id) {
return createMiddleware(name,
id,
"HandleSerialize",
SymbolUtils.createValueSymbolBuilder("SerializeInput", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("SerializeOutput", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("SerializeHandler", SmithyGoDependency.SMITHY_MIDDLEWARE).build());
}
/**
* Create a new FinalizeStep middleware generator with the provided type name.
*
* @param name is the type name to identify the middleware.
* @param id the unique ID for the middleware.
* @return the middleware generator.
*/
public static GoStackStepMiddlewareGenerator createFinalizeStepMiddleware(String name, MiddlewareIdentifier id) {
return createMiddleware(name,
id,
"HandleFinalize",
SmithyGoTypes.Middleware.FinalizeInput,
SmithyGoTypes.Middleware.FinalizeOutput,
SmithyGoTypes.Middleware.FinalizeHandler);
}
/**
* Create an inline Finalize func.
*
* @param body is the function body.
* @return the generated middleware func.
*/
public static GoWriter.Writable generateFinalizeMiddlewareFunc(GoWriter.Writable body) {
return goTemplate("""
func(ctx $T, in $T, next $T) (
out $T, metadata $T, err error,
) {
$W
}
""",
GoStdlibTypes.Context.Context,
SmithyGoTypes.Middleware.FinalizeInput,
SmithyGoTypes.Middleware.FinalizeHandler,
SmithyGoTypes.Middleware.FinalizeOutput,
SmithyGoTypes.Middleware.Metadata,
body);
}
/**
* Create a new DeserializeStep middleware generator with the provided type name.
*
* @param name is the type name to identify the middleware.
* @param id the unique ID for the middleware.
* @return the middleware generator.
*/
public static GoStackStepMiddlewareGenerator createDeserializeStepMiddleware(String name, MiddlewareIdentifier id) {
return createMiddleware(name,
id,
"HandleDeserialize",
SymbolUtils.createValueSymbolBuilder("DeserializeInput", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("DeserializeOutput", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("DeserializeHandler", SmithyGoDependency.SMITHY_MIDDLEWARE)
.build());
}
/**
* Generates a new step middleware generator.
*
* @param name the name of the middleware type.
* @param id the unique ID for the middleware.
* @param handlerMethodName method name to be implemented.
* @param inputType the middleware input type.
* @param outputType the middleware output type.
* @param handlerType the next handler type.
* @return the middleware generator.
*/
public static GoStackStepMiddlewareGenerator createMiddleware(
String name,
MiddlewareIdentifier id,
String handlerMethodName,
Symbol inputType,
Symbol outputType,
Symbol handlerType
) {
return builder()
.name(name)
.id(id)
.handleMethodName(handlerMethodName)
.inputType(inputType)
.outputType(outputType)
.handlerType(handlerType)
.build();
}
/**
* Writes the middleware definition to the provided writer.
* See the writeMiddleware overloaded function signature for a more complete definition.
*
* @param writer the writer to which the middleware definition will be written to.
* @param handlerBodyConsumer is a consumer that will be call in the context of populating the handler definition.
*/
public void writeMiddleware(
GoWriter writer,
BiConsumer handlerBodyConsumer
) {
writeMiddleware(writer, handlerBodyConsumer, (m, w) -> {
});
}
/**
* Writes the middleware definition to the provided writer.
*
* The following Go variables will be in scope of the handler body:
* ctx - the Go standard library context.Context type.
* in - the input for the given middleware type.
* next - the next handler to be called.
* out - the output for the given middleware type.
* metadata - the smithy middleware.Metadata type.
* err - the error interface type.
*
* @param writer the writer to which the middleware definition will be written to.
* @param handlerBodyConsumer is a consumer that will be called in the context of populating the handler definition.
* @param fieldConsumer is a consumer that will be called in the context of populating the struct members.
*/
public void writeMiddleware(
GoWriter writer,
BiConsumer handlerBodyConsumer,
BiConsumer fieldConsumer
) {
writer.addUseImports(CONTEXT_TYPE);
writer.addUseImports(METADATA_TYPE);
writer.addUseImports(inputType);
writer.addUseImports(outputType);
writer.addUseImports(handlerType);
// generate the structure type definition for the middleware
writer.openBlock("type $L struct {", "}", middlewareSymbol, () -> {
fieldConsumer.accept(this, writer);
});
writer.write("");
// each middleware step has to implement the ID function and return a unique string to identify itself with
// here we return the name of the type
writer.openBlock("func ($P) ID() string {", "}", middlewareSymbol, () -> {
writer.writeInline("return ");
middlewareId.writeInline(writer);
writer.write("");
});
writer.write("");
// each middleware must implement their given handlerMethodName in order to satisfy the interface for
// their respective step.
writer.openBlock("func (m $P) $L(ctx $T, in $T, next $T) (\n"
+ "\tout $T, metadata $T, err error,\n"
+ ") {", "}",
new Object[]{
middlewareSymbol, handleMethodName, CONTEXT_TYPE, inputType, handlerType, outputType,
METADATA_TYPE,
},
() -> {
handlerBodyConsumer.accept(this, writer);
});
}
/**
* Creates a Writable which renders the middleware.
* @param body A Writable that renders the middleware body.
* @param fields A Writable that renders the middleware struct's fields.
* @return the writable.
*/
public GoWriter.Writable asWritable(GoWriter.Writable body, GoWriter.Writable fields) {
return writer -> writeMiddleware(
writer,
(generator, bodyWriter) -> bodyWriter.write("$W", body),
(generator, fieldWriter) -> fieldWriter.write("$W", fields)
);
}
/**
* Returns a new middleware generator builder.
*
* @return the middleware generator builder.
*/
public static Builder builder() {
return new Builder();
}
/**
* Get the handle method name.
*
* @return handler method name.
*/
public String getHandleMethodName() {
return handleMethodName;
}
/**
* Get the middleware type symbol.
*
* @return Symbol for the middleware type.
*/
public Symbol getMiddlewareSymbol() {
return middlewareSymbol;
}
/**
* Get the id of the middleware.
*
* @return id for the middleware.
*/
public MiddlewareIdentifier getMiddlewareId() {
return middlewareId;
}
/**
* Get the input type symbol reference.
*
* @return the input type symbol reference.
*/
public Symbol getInputType() {
return inputType;
}
/**
* Get the output type symbol reference.
*
* @return the output type symbol reference.
*/
public Symbol getOutputType() {
return outputType;
}
/**
* Get the handler type symbol reference.
*
* @return the handler type symbol reference.
*/
public Symbol getHandlerType() {
return handlerType;
}
/**
* Get the context type symbol.
*
* @return the context type symbol.
*/
public static Symbol getContextType() {
return CONTEXT_TYPE;
}
/**
* Get the middleware metadata type symbol.
*
* @return the middleware metadata type symbol.
*/
public static Symbol getMiddlewareMetadataType() {
return METADATA_TYPE;
}
/**
* Builds a {@link GoStackStepMiddlewareGenerator}.
*/
public static class Builder {
private String name;
private MiddlewareIdentifier id;
private String handleMethodName;
private Symbol inputType;
private Symbol outputType;
private Symbol handlerType;
/**
* Builds the middleware generator.
*
* @return the middleware generator.
*/
public GoStackStepMiddlewareGenerator build() {
return new GoStackStepMiddlewareGenerator(this);
}
/**
* Sets the handler method name.
*
* @param handleMethodName the middleware handler method name to implement.
* @return the builder.
*/
public Builder handleMethodName(String handleMethodName) {
this.handleMethodName = handleMethodName;
return this;
}
/**
* Set the name of the middleware type to be generated.
*
* @param name the name of the middleware type.
* @return the builder.
*/
public Builder name(String name) {
this.name = name;
return this;
}
/**
* Set the id for the middleware to be generated.
*
* @param id the middleware stack identifier.
* @return the builder.
*/
public Builder id(MiddlewareIdentifier id) {
this.id = id;
return this;
}
/**
* Set the input type symbol reference for the middleware.
*
* @param inputType the symbol reference to the input type.
* @return the builder.
*/
public Builder inputType(Symbol inputType) {
this.inputType = inputType;
return this;
}
/**
* Set the output type symbol reference for the middleware.
*
* @param outputType the symbol reference to the output type.
* @return the builder.
*/
public Builder outputType(Symbol outputType) {
this.outputType = outputType;
return this;
}
/**
* Set the handler type symbol reference for the middleware.
*
* @param handlerType the symbol reference to the handler type.
* @return the builder.
*/
public Builder handlerType(Symbol handlerType) {
this.handlerType = handlerType;
return this;
}
}
}
GoStdlibTypes.java 0000664 0000000 0000000 00000007012 15102203672 0035064 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import software.amazon.smithy.codegen.core.Symbol;
/**
* Collection of Symbol constants for types in the go standard library.
*/
public final class GoStdlibTypes {
private GoStdlibTypes() { }
public static final class Bytes {
public static final Symbol NewReader = SmithyGoDependency.BYTES.valueSymbol("NewReader");
}
public static final class Context {
public static final Symbol Context = SmithyGoDependency.CONTEXT.valueSymbol("Context");
public static final Symbol Background = SmithyGoDependency.CONTEXT.valueSymbol("Background");
}
public static final class Time {
public static final Symbol Time = SmithyGoDependency.TIME.pointableSymbol("Time");
}
public static final class Encoding {
public static final class Json {
public static final Symbol NewDecoder = SmithyGoDependency.JSON.valueSymbol("NewDecoder");
public static final Symbol Number = SmithyGoDependency.JSON.valueSymbol("Number");
}
public static final class Base64 {
public static final Symbol StdEncoding = SmithyGoDependency.BASE64.valueSymbol("StdEncoding");
}
}
public static final class Crypto {
public static final class Rand {
public static final Symbol Reader = SmithyGoDependency.CRYPTORAND.valueSymbol("Reader");
}
}
public static final class Fmt {
public static final Symbol Errorf = SmithyGoDependency.FMT.valueSymbol("Errorf");
public static final Symbol Sprintf = SmithyGoDependency.FMT.valueSymbol("Sprintf");
}
public static final class Io {
public static final Symbol ReadAll = SmithyGoDependency.IO.valueSymbol("ReadAll");
public static final Symbol Copy = SmithyGoDependency.IO.valueSymbol("Copy");
public static final class IoUtil {
public static final Symbol Discard = SmithyGoDependency.IOUTIL.valueSymbol("Discard");
}
}
public static final class Net {
public static final class Http {
public static final Symbol Request = SmithyGoDependency.NET_HTTP.pointableSymbol("Request");
public static final Symbol Response = SmithyGoDependency.NET_HTTP.pointableSymbol("Response");
public static final Symbol Server = SmithyGoDependency.NET_HTTP.pointableSymbol("Server");
public static final Symbol Handler = SmithyGoDependency.NET_HTTP.valueSymbol("Handler");
public static final Symbol ResponseWriter = SmithyGoDependency.NET_HTTP.valueSymbol("ResponseWriter");
public static final Symbol MethodPost = SmithyGoDependency.NET_HTTP.valueSymbol("MethodPost");
}
}
public static final class Path {
public static final Symbol Join = SmithyGoDependency.PATH.valueSymbol("Join");
}
public static final class Testing {
public static final Symbol T = SmithyGoDependency.TESTING.pointableSymbol("T");
}
}
GoUniverseTypes.java 0000664 0000000 0000000 00000004525 15102203672 0035451 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import software.amazon.smithy.codegen.core.Symbol;
/**
* Collection of Symbol constants for golang universe types.
* See predeclared identifiers.
*/
public final class GoUniverseTypes {
public static final Symbol Any = universe("any");
public static final Symbol Bool = universe("bool");
public static final Symbol Byte = universe("byte");
public static final Symbol Comparable = universe("comparable");
public static final Symbol Complex64 = universe("complex64");
public static final Symbol Complex128 = universe("complex128");
public static final Symbol Error = universe("error");
public static final Symbol Float32 = universe("float32");
public static final Symbol Float64 = universe("float64");
public static final Symbol Int = universe("int");
public static final Symbol Int8 = universe("int8");
public static final Symbol Int16 = universe("int16");
public static final Symbol Int32 = universe("int32");
public static final Symbol Int64 = universe("int64");
public static final Symbol Rune = universe("rune");
public static final Symbol String = universe("string");
public static final Symbol Uint = universe("uint");
public static final Symbol Uint8 = universe("uint8");
public static final Symbol Uint16 = universe("uint16");
public static final Symbol Uint32 = universe("uint32");
public static final Symbol Uint64 = universe("uint64");
public static final Symbol Uintptr = universe("uintptr");
private GoUniverseTypes() {}
private static Symbol universe(String name) {
return SymbolUtils.createValueSymbolBuilder(name).putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
}
}
GoValueAccessUtils.java 0000664 0000000 0000000 00000031245 15102203672 0036042 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*
*
*/
package software.amazon.smithy.go.codegen;
import java.util.function.Consumer;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.knowledge.GoPointableIndex;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeType;
import software.amazon.smithy.model.traits.EnumTrait;
/**
* Utilities for generating accessor checks around other generated blocks.
*/
public final class GoValueAccessUtils {
private GoValueAccessUtils() {
}
/**
* Writes non-zero conditional checks around a lambda specific to the member shape type.
*
* Note: Collections and map member values by default will not have individual checks on member values. To check
* not empty strings set the ignoreEmptyString to false.
*
* @param model smithy model
* @param writer go writer
* @param member API shape member to determine wrapping check with
* @param operand string of text with access to value
* @param ignoreEmptyString if empty strings also checked
* @param ignoreUnboxedTypes if unboxed member types should be ignored
* @param lambda lambda to run
*/
public static void writeIfNonZeroValue(
Model model,
GoWriter writer,
MemberShape member,
String operand,
boolean ignoreEmptyString,
boolean ignoreUnboxedTypes,
Runnable lambda
) {
Shape targetShape = model.expectShape(member.getTarget());
Shape container = model.expectShape(member.getContainer());
// default to empty block for variable scoping with not value check.
String check = "{";
if (GoPointableIndex.of(model).isNillable(member)) {
if (!ignoreEmptyString && targetShape.getType() == ShapeType.STRING) {
check = String.format("if %s != nil && len(*%s) > 0 {", operand, operand);
} else {
check = String.format("if %s != nil {", operand);
}
} else if (container instanceof CollectionShape || container.getType() == ShapeType.MAP) {
if (!ignoreEmptyString && targetShape.getType() == ShapeType.STRING) {
check = String.format("if len(%s) > 0 {", operand);
} else if (!ignoreEmptyString && targetShape.getType() == ShapeType.ENUM) {
check = String.format("if len(%s) > 0 {", operand);
}
} else if (targetShape.hasTrait(EnumTrait.class)) {
check = String.format("if len(%s) > 0 {", operand);
} else if (!ignoreUnboxedTypes && targetShape.getType() == ShapeType.BOOLEAN) {
check = String.format("if %s {", operand);
} else if (!ignoreUnboxedTypes && CodegenUtils.isNumber(targetShape)) {
check = String.format("if %s != 0 {", operand);
} else if (!ignoreEmptyString && targetShape.getType() == ShapeType.STRING) {
check = String.format("if len(%s) > 0 {", operand);
}
writer.openBlock(check, "}", lambda);
}
/**
* Writes non-zero conditional checks around a lambda specific to the member shape type.
*
* Ignores empty strings of string pointers, and nested within list and maps.
*
* @param model smithy model
* @param writer go writer
* @param member API shape member to determine wrapping check with
* @param operand string of text with access to value
* @param lambda lambda to run
*/
public static void writeIfNonZeroValue(
Model model,
GoWriter writer,
MemberShape member,
String operand,
Runnable lambda
) {
writeIfNonZeroValue(model, writer, member, operand, true, false, lambda);
}
/**
* Writes non-zero conditional check around a lambda specific to a member of a container.
*
* Ignores empty strings of string pointers, and members nested within list and maps.
*
* @param model smithy model
* @param symbolProvider symbol provider
* @param writer go writer
* @param member API shape member to determine wrapping check with
* @param container operand of source member is a part of.
* @param lambda lambda to run
*/
public static void writeIfNonZeroValueMember(
Model model,
SymbolProvider symbolProvider,
GoWriter writer,
MemberShape member,
String container,
Consumer lambda
) {
writeIfNonZeroValueMember(model, symbolProvider, writer, member, container, true, false, lambda);
}
/**
* Writes non-zero conditional check around a lambda specific to a member of a container.
*
* Note: Collections and map member values by default will not have individual checks on member values. To check
* not empty strings set the ignoreEmptyString to false.
*
* @param model smithy model
* @param symbolProvider symbol provider
* @param writer go writer
* @param member API shape member to determine wrapping check with
* @param container operand of source member is a part of.
* @param ignoreEmptyString if empty strings also checked
* @param ignoreUnboxedTypes if unboxed member types should be ignored
* @param lambda lambda to run
*/
public static void writeIfNonZeroValueMember(
Model model,
SymbolProvider symbolProvider,
GoWriter writer,
MemberShape member,
String container,
boolean ignoreEmptyString,
boolean ignoreUnboxedTypes,
Consumer lambda
) {
String memberName = symbolProvider.toMemberName(member);
String operand = container + "." + memberName;
writeIfNonZeroValue(model, writer, member, operand, ignoreEmptyString, ignoreUnboxedTypes, () -> {
lambda.accept(operand);
});
}
/**
* Writes zero conditional checks around a lambda specific to the member shape type.
*
* Members with containers of Collection and map shapes, will ignore the lambda block
* and not call it. Optionally will ignore empty strings based on the ignoreEmptyString flag.
*
* Non-nillable shapes other than Enum, Boolean, and Number will ignore the lambda block. Optionally will ignore
* empty strings based on the ignoreEmptyString flag.
*
* Note: Collections and map member values by default will not have individual checks on member values. To check
* for empty strings set the ignoreEmptyString to false.
*
* @param model smithy model
* @param writer go writer
* @param member API shape member to determine wrapping check with
* @param operand string of text with access to value
* @param ignoreEmptyString if empty strings also checked
* @param ignoreUnboxedTypes if unboxed member types should be ignored
* @param lambda lambda to run
*/
public static void writeIfZeroValue(
Model model,
GoWriter writer,
MemberShape member,
String operand,
boolean ignoreEmptyString,
boolean ignoreUnboxedTypes,
Runnable lambda
) {
Shape targetShape = model.expectShape(member.getTarget());
Shape container = model.expectShape(member.getContainer());
String check = "{";
if (GoPointableIndex.of(model).isNillable(member)) {
if (!ignoreEmptyString && targetShape.getType() == ShapeType.STRING) {
check = String.format("if %s == nil || len(*%s) == 0 {", operand, operand);
} else {
check = String.format("if %s == nil {", operand);
}
} else if (container instanceof CollectionShape || container.getType() == ShapeType.MAP) {
// Always serialize values in map/list/sets, no additional check, which means that the
// lambda will not be run, because there is no zero value to check against.
if (!ignoreEmptyString && targetShape.getType() == ShapeType.STRING) {
check = String.format("if len(%s) == 0 {", operand);
} else {
return;
}
} else if (targetShape.hasTrait(EnumTrait.class)) {
check = String.format("if len(%s) == 0 {", operand);
} else if (!ignoreUnboxedTypes && targetShape.getType() == ShapeType.BOOLEAN) {
check = String.format("if !%s {", operand);
} else if (!ignoreUnboxedTypes && CodegenUtils.isNumber(targetShape)) {
check = String.format("if %s == 0 {", operand);
} else if (!ignoreEmptyString && targetShape.getType() == ShapeType.STRING) {
check = String.format("if len(%s) == 0 {", operand);
} else {
// default to empty block for variable scoping with not value check.
return;
}
writer.openBlock(check, "}", lambda);
}
/**
* Writes zero conditional checks around a lambda specific to the member shape type.
*
* Ignores empty strings of string pointers, and members nested within list and maps.
*
* @param model smithy model
* @param writer go writer
* @param member API shape member to determine wrapping check with
* @param operand string of text with access to value
* @param lambda lambda to run
*/
public static void writeIfZeroValue(
Model model,
GoWriter writer,
MemberShape member,
String operand,
Runnable lambda
) {
writeIfZeroValue(model, writer, member, operand, true, false, lambda);
}
/**
* Writes zero conditional check around a lambda specific to a member of a container.
*
* Ignores empty strings of string pointers, and members nested within list and maps.
*
* @param model smithy model
* @param symbolProvider symbol provider
* @param writer go writer
* @param member API shape member to determine wrapping check with
* @param container operand of source member is a part of.
* @param lambda lambda to run
*/
public static void writeIfZeroValueMember(
Model model,
SymbolProvider symbolProvider,
GoWriter writer,
MemberShape member,
String container,
Consumer lambda
) {
writeIfZeroValueMember(model, symbolProvider, writer, member, container, true, false, lambda);
}
/**
* Writes zero conditional check around a lambda specific to a member of a container.
*
* Ignores empty strings of string pointers, and members nested within list and maps.
*
* @param model smithy model
* @param symbolProvider symbol provider
* @param writer go writer
* @param member API shape member to determine wrapping check with
* @param container operand of source member is a part of.
* @param ignoreEmptyString if empty strings also checked
* @param ignoreUnboxedTypes if unboxed member types should be ignored
* @param lambda lambda to run
*/
public static void writeIfZeroValueMember(
Model model,
SymbolProvider symbolProvider,
GoWriter writer,
MemberShape member,
String container,
boolean ignoreEmptyString,
boolean ignoreUnboxedTypes,
Consumer lambda
) {
String memberName = symbolProvider.toMemberName(member);
String operand = container + "." + memberName;
writeIfZeroValue(model, writer, member, operand, ignoreEmptyString, ignoreUnboxedTypes, () -> {
lambda.accept(operand);
});
}
}
GoWriter.java 0000664 0000000 0000000 00000113103 15102203672 0034071 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolContainer;
import software.amazon.smithy.codegen.core.SymbolReference;
import software.amazon.smithy.codegen.core.SymbolWriter;
import software.amazon.smithy.go.codegen.knowledge.GoUsageIndex;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.loader.Prelude;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.traits.DeprecatedTrait;
import software.amazon.smithy.model.traits.DocumentationTrait;
import software.amazon.smithy.model.traits.HttpPrefixHeadersTrait;
import software.amazon.smithy.model.traits.MediaTypeTrait;
import software.amazon.smithy.model.traits.RequiredTrait;
import software.amazon.smithy.model.traits.StringTrait;
import software.amazon.smithy.utils.AbstractCodeWriter;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.SmithyInternalApi;
import software.amazon.smithy.utils.StringUtils;
/**
* Specialized code writer for managing Go dependencies.
*
* Use the {@code $T} formatter to refer to {@link Symbol}s without using pointers.
*
*
Use the {@code $P} formatter to refer to {@link Symbol}s using pointers where appropriate.
*/
@SmithyInternalApi
public final class GoWriter extends SymbolWriter {
private static final Logger LOGGER = Logger.getLogger(GoWriter.class.getName());
private static final int DEFAULT_DOC_WRAP_LENGTH = 80;
private static final Pattern ARGUMENT_NAME_PATTERN = Pattern.compile("\\$([a-z][a-zA-Z_0-9]\\.+)(:\\w)?");
private final String fullPackageName;
private final boolean innerWriter;
private final List buildTags = new ArrayList<>();
private int docWrapLength = DEFAULT_DOC_WRAP_LENGTH;
private AbstractCodeWriter packageDocs;
/**
* Initializes the GoWriter for the package and filename to be written to.
*
* @param fullPackageName package and filename to be written to.
*/
public GoWriter(String fullPackageName) {
super(new ImportDeclarations(fullPackageName));
this.fullPackageName = fullPackageName;
this.innerWriter = false;
init();
}
private GoWriter(String fullPackageName, boolean innerWriter) {
super(new ImportDeclarations(fullPackageName));
this.fullPackageName = fullPackageName;
this.innerWriter = innerWriter;
init();
}
private void init() {
trimBlankLines();
trimTrailingSpaces();
setIndentText("\t");
putFormatter('T', new GoSymbolFormatter());
putFormatter('P', new PointableGoSymbolFormatter());
putFormatter('W', new GoWritableInjector());
putFormatter('D', new GoDependencyFormatter());
putContext("fmt.Sprintf", SmithyGoDependency.FMT.func("Sprintf"));
putContext("fmt.Errorf", SmithyGoDependency.FMT.func("Errorf"));
putContext("errors.As", SmithyGoDependency.ERRORS.func("As"));
putContext("context.Context", SmithyGoDependency.CONTEXT.func("Context"));
putContext("time.Now", SmithyGoDependency.TIME.func("Now"));
if (!innerWriter) {
packageDocs = new GoWriter(this.fullPackageName, true);
}
}
// TODO figure out better way to annotate where the failure occurs, check templates and args
// TODO to try to find programming bugs.
/**
* Joins multiple writables together within a single writable without newlines between writables in the list.
*
* @param writables list of writables to join
* @param separator separator between writables
* @return new writable
*/
public static Writable joinWritables(List writables, String separator) {
return (GoWriter w) -> {
for (int i = 0; i < writables.size(); i++) {
var writable = writables.get(i);
var sep = separator;
if (i == writables.size() - 1) {
sep = "";
}
w.writeInline("$W" + sep, writable);
}
};
}
/**
* Returns a Writable for the string and args to be composed inline to another writer's contents.
*
* @param contents string to write.
* @param args Arguments to use when evaluating the contents string.
* @return Writable to be evaluated.
*/
@SafeVarargs
public static Writable goTemplate(String contents, Map... args) {
validateTemplateArgsNotNull(args);
return (GoWriter w) -> {
w.writeGoTemplate(contents, args);
};
}
/**
* Returns a Writable for the string and args to be composed inline to another writer's contents.
*
* @param content string to write.
* @param args Arguments to use when evaluating the contents string.
* @return Writable to be evaluated.
*/
public static Writable goTemplate(Object content, Object... args) {
return writer -> writer.write(content, args);
}
public static Writable goDocTemplate(String contents) {
return goDocTemplate(contents, new HashMap<>());
}
/**
* Auto-formats a multi-paragraph string as a doc writable (including line wrapping).
* @param contents The docs.
* @return writer for formatted docs.
*/
public static Writable autoDocTemplate(String contents) {
var paragraphs = contents.split("\n\n");
var chain = new GoWriter.ChainWritable();
for (int i = 0; i < paragraphs.length; ++i) {
chain.add(docParagraphWriter(paragraphs[i], i < paragraphs.length - 1));
}
return chain.compose(false);
}
private static GoWriter.Writable docParagraphWriter(String paragraph, boolean writeNewline) {
return writer -> {
writer.writeDocs(paragraph);
if (writeNewline) {
writer.writeDocs("");
}
};
}
@SafeVarargs
public static Writable goDocTemplate(String contents, Map... args) {
validateTemplateArgsNotNull(args);
return (GoWriter w) -> {
w.writeGoDocTemplate(contents, args);
};
}
/**
* Returns a Writable that can later be invoked to write the contents as template
* as a code block instead of single content of text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param fn closure to write
*/
public static Writable goBlockTemplate(
String beforeNewLine,
String afterNewLine,
Consumer fn
) {
return goBlockTemplate(beforeNewLine, afterNewLine, new Map[0], fn);
}
/**
* Returns a Writable that can later be invoked to write the contents as template
* as a code block instead of single content of text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param args1 template arguments
* @param fn closure to write
*/
public static Writable goBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map args1,
Consumer fn
) {
return goBlockTemplate(beforeNewLine, afterNewLine, new Map[]{args1}, fn);
}
/**
* Returns a Writable that can later be invoked to write the contents as template
* as a code block instead of single content of text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param args1 template arguments
* @param args2 template arguments
* @param fn closure to write
*/
public static Writable goBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map args1,
Map args2,
Consumer fn
) {
return goBlockTemplate(beforeNewLine, afterNewLine, new Map[]{args1, args2}, fn);
}
/**
* Returns a Writable that can later be invoked to write the contents as template
* as a code block instead of single content of text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param args1 template arguments
* @param args2 template arguments
* @param args3 template arguments
* @param fn closure to write
*/
public static Writable goBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map args1,
Map args2,
Map args3,
Consumer fn
) {
return goBlockTemplate(beforeNewLine, afterNewLine, new Map[]{args1, args2, args3}, fn);
}
/**
* Returns a Writable that can later be invoked to write the contents as template
* as a code block instead of single content of text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param args1 template arguments
* @param args2 template arguments
* @param args3 template arguments
* @param args4 template arguments
* @param fn closure to write
*/
public static Writable goBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map args1,
Map args2,
Map args3,
Map args4,
Consumer fn
) {
return goBlockTemplate(beforeNewLine, afterNewLine, new Map[]{args1, args2, args3, args4}, fn);
}
/**
* Returns a Writable that can later be invoked to write the contents as template
* as a code block instead of single content of text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param args1 template arguments
* @param args2 template arguments
* @param args3 template arguments
* @param args4 template arguments
* @param args5 template arguments
* @param fn closure to write
*/
public static Writable goBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map args1,
Map args2,
Map args3,
Map args4,
Map args5,
Consumer fn
) {
return goBlockTemplate(beforeNewLine, afterNewLine, new Map[]{args1, args2, args3, args4, args5}, fn);
}
/**
* Returns a Writable that can later be invoked to write the contents as template
* as a code block instead of single content of text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param args template arguments
* @param fn closure to write
*/
public static Writable goBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map[] args,
Consumer fn
) {
validateTemplateArgsNotNull(args);
return (GoWriter w) -> {
w.writeGoBlockTemplate(beforeNewLine, afterNewLine, args, fn);
};
}
/**
* Returns a Writable that does nothing.
*
* @return Writable that does nothing
*/
public static Writable emptyGoTemplate() {
return (GoWriter w) -> {
};
}
/**
* Writes the contents and arguments as a template to the writer.
*
* @param contents string to write
* @param args Arguments to use when evaluating the contents string.
*/
@SafeVarargs
public final void writeGoTemplate(String contents, Map... args) {
withTemplate(contents, args, (template) -> {
try {
write(contents);
} catch (Exception e) {
throw new CodegenException("Failed to render template\n" + contents + "\nReason: " + e.getMessage(), e);
}
});
}
@SafeVarargs
public final void writeGoDocTemplate(String contents, Map... args) {
writeRenderedDocs(goTemplate(contents, args));
}
/**
* Writes the contents as template as a code block instead of single content fo text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param fn closure to write
*/
public void writeGoBlockTemplate(
String beforeNewLine,
String afterNewLine,
Consumer fn
) {
writeGoBlockTemplate(beforeNewLine, afterNewLine, new Map[0], fn);
}
/**
* Writes the contents as template as a code block instead of single content fo text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param arg1 first map argument
* @param fn closure to write
*/
public void writeGoBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map arg1,
Consumer fn
) {
writeGoBlockTemplate(beforeNewLine, afterNewLine, new Map[]{arg1}, fn);
}
/**
* Writes the contents as template as a code block instead of single content fo text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param arg1 first map argument
* @param arg2 second map argument
* @param fn closure to write
*/
public void writeGoBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map arg1,
Map arg2,
Consumer fn
) {
writeGoBlockTemplate(beforeNewLine, afterNewLine, new Map[]{arg1, arg2}, fn);
}
/**
* Writes the contents as template as a code block instead of single content fo text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param arg1 first map argument
* @param arg2 second map argument
* @param arg3 third map argument
* @param fn closure to write
*/
public void writeGoBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map arg1,
Map arg2,
Map arg3,
Consumer fn
) {
writeGoBlockTemplate(beforeNewLine, afterNewLine, new Map[]{arg1, arg2, arg3}, fn);
}
/**
* Writes the contents as template as a code block instead of single content fo text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param arg1 first map argument
* @param arg2 second map argument
* @param arg3 third map argument
* @param arg4 forth map argument
* @param fn closure to write
*/
public void writeGoBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map arg1,
Map arg2,
Map arg3,
Map arg4,
Consumer fn
) {
writeGoBlockTemplate(beforeNewLine, afterNewLine, new Map[]{arg1, arg2, arg3, arg4}, fn);
}
/**
* Writes the contents as template as a code block instead of single content fo text.
*
* @param beforeNewLine text before new line
* @param afterNewLine text after new line
* @param arg1 first map argument
* @param arg2 second map argument
* @param arg3 third map argument
* @param arg4 forth map argument
* @param arg5 forth map argument
* @param fn closure to write
*/
public void writeGoBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map arg1,
Map arg2,
Map arg3,
Map arg4,
Map arg5,
Consumer fn
) {
writeGoBlockTemplate(beforeNewLine, afterNewLine, new Map[]{arg1, arg2, arg3, arg4, arg5}, fn);
}
public void writeGoBlockTemplate(
String beforeNewLine,
String afterNewLine,
Map[] args,
Consumer fn
) {
withTemplate(beforeNewLine, args, (header) -> {
conditionalBlock(header, afterNewLine, true, new Object[0], fn);
});
}
private void withTemplate(
String template,
Map[] argMaps,
Consumer fn
) {
pushState();
for (var args : argMaps) {
putContext(args);
}
validateContext(template);
fn.accept(template);
popState();
}
private GoWriter conditionalBlock(
String beforeNewLine,
String afterNewLine,
boolean conditional,
Object[] args,
Consumer fn
) {
if (conditional) {
openBlock(beforeNewLine.trim(), args);
}
fn.accept(this);
if (conditional) {
closeBlock(afterNewLine.trim());
}
return this;
}
private static void validateTemplateArgsNotNull(Map[] argMaps) {
for (var args : argMaps) {
args.forEach((k, v) -> {
if (v == null) {
throw new CodegenException("Template argument " + k + " cannot be null");
}
});
}
}
private void validateContext(String template) {
var matcher = ARGUMENT_NAME_PATTERN.matcher(template);
while (matcher.find()) {
var keyName = matcher.group(1);
var value = getContext(keyName);
if (value == null) {
throw new CodegenException(
"Go template expected " + keyName + " but was not present in context scope."
+ " Template: \n" + template);
}
}
}
/**
* Sets the wrap length of doc strings written.
*
* @param wrapLength The wrap length of the doc string.
* @return Returns the writer.
*/
public GoWriter setDocWrapLength(final int wrapLength) {
this.docWrapLength = wrapLength;
return this;
}
/**
* Sets the wrap length of doc strings written to the default value for the Go writer.
*
* @return Returns the writer.
*/
public GoWriter setDocWrapLength() {
this.docWrapLength = DEFAULT_DOC_WRAP_LENGTH;
return this;
}
/**
* Imports one or more symbols if necessary, using the name of the
* symbol and only "USE" references.
*
* @param container Container of symbols to add.
* @return Returns the writer.
*/
public GoWriter addUseImports(SymbolContainer container) {
for (Symbol symbol : container.getSymbols()) {
addImport(symbol,
CodegenUtils.getSymbolNamespaceAlias(symbol),
SymbolReference.ContextOption.USE);
}
return this;
}
/**
* Imports a symbol reference if necessary, using the alias of the
* reference and only associated "USE" references.
*
* @param symbolReference Symbol reference to import.
* @return Returns the writer.
*/
public GoWriter addUseImports(SymbolReference symbolReference) {
return addImport(symbolReference.getSymbol(), symbolReference.getAlias(), SymbolReference.ContextOption.USE);
}
/**
* Adds and imports the given dependency.
*
* @param goDependency The GoDependency to import.
* @return Returns the writer.
*/
public GoWriter addUseImports(GoDependency goDependency) {
addDependency(goDependency);
return addImport(goDependency.getImportPath(), goDependency.getAlias());
}
private void addImports(GoWriter other) {
this.getImportContainer().addImports(other.getImportContainer());
}
private boolean isExternalNamespace(String namespace) {
return !StringUtils.isBlank(namespace) && !namespace.equals(fullPackageName);
}
void addImportReferences(Symbol symbol, SymbolReference.ContextOption... options) {
for (SymbolReference reference : symbol.getReferences()) {
for (SymbolReference.ContextOption option : options) {
if (reference.hasOption(option)) {
addImport(reference.getSymbol(), reference.getAlias(), options);
break;
}
}
}
}
/**
* Imports a package using an alias if necessary.
*
* @param packageName Package to import.
* @param as Alias to refer to the package as.
* @return Returns the writer.
*/
public GoWriter addImport(String packageName, String as) {
getImportContainer().addImport(packageName, as);
return this;
}
private void addDependencies(GoWriter other) {
addDependency(other);
}
/**
* Writes documentation comments.
*
* @param runnable Runnable that handles actually writing docs with the writer.
* @return Returns the writer.
*/
private void writeDocs(AbstractCodeWriter writer, Runnable runnable) {
writer.pushState("docs");
writer.setNewlinePrefix("// ");
runnable.run();
writer.setNewlinePrefix("");
writer.popState();
}
private void writeDocs(AbstractCodeWriter writer, int docWrapLength, String docs) {
String convertedDoc = DocumentationConverter.convert(docs, docWrapLength);
writeDocs(writer, () -> writer.write(convertedDoc.replace("$", "$$")));
}
/**
* Writes documentation comments from a string.
*
* This function escapes "$" characters so formatters are not run.
*
* @param docs Documentation to write.
* @return Returns the writer.
*/
public GoWriter writeDocs(String docs) {
writeDocs(this, docWrapLength, docs);
return this;
}
/**
* Writes documentation from an arbitrary Writable.
*
* @param writable Contents to be written.
* @return Returns the writer.
*/
public GoWriter writeRenderedDocs(Writable writable) {
writeRenderedDocs(this, docWrapLength, writable);
return this;
}
private void writeRenderedDocs(AbstractCodeWriter writer, int docWrapLength, Writable writable) {
var innerWriter = new GoWriter(fullPackageName, true);
writable.accept(innerWriter);
var wrappedDocs = StringUtils.wrap(innerWriter.toString().trim(), docWrapLength);
writeDocs(writer, () -> writer.write(wrappedDocs.replace("$", "$$")));
}
/**
* Writes the doc to the Go package docs that are written prior to the go package statement.
*
* @param docs documentation to write to package doc.
* @return writer
*/
public GoWriter writePackageDocs(String docs) {
writeDocs(packageDocs, docWrapLength, docs);
return this;
}
/**
* Writes the doc to the Go package docs that are written prior to the go package statement. This does not perform
* line wrapping and the provided formatting must be valid Go doc.
*
* @param docs documentation to write to package doc.
* @return writer
*/
public GoWriter writeRawPackageDocs(String docs) {
writeDocs(packageDocs, () -> {
packageDocs.write(docs);
});
return this;
}
/**
* Writes shape documentation comments if docs are present.
*
* @param shape Shape to write the documentation of.
* @return Returns true if docs were written.
*/
@SmithyInternalApi
public boolean writeShapeDocs(Shape shape) {
return shape.getTrait(DocumentationTrait.class)
.map(DocumentationTrait::getValue)
.map(docs -> {
writeDocs(docs);
return true;
}).orElse(false);
}
/**
* Writes shape documentation comments to the writer's package doc if docs are present.
*
* @param shape Shape to write the documentation of.
* @return Returns true if docs were written.
*/
public boolean writePackageShapeDocs(Shape shape) {
return shape.getTrait(DocumentationTrait.class)
.map(DocumentationTrait::getValue)
.map(docs -> {
writePackageDocs(docs);
if (shape.hasTrait(DeprecatedTrait.class)) {
var message = shape.expectTrait(DeprecatedTrait.class)
.getMessage()
.orElse("This package is deprecated.");
writePackageDocs("");
writePackageDocs("Deprecated: " + message);
}
return true;
}).orElse(false);
}
/**
* Writes member shape documentation comments if docs are present.
*
* @param model Model used to dereference targets.
* @param member Shape to write the documentation of.
* @return Returns true if docs were written.
*/
public boolean writeMemberDocs(Model model, MemberShape member) {
boolean hasDocs;
hasDocs = member.getMemberTrait(model, DocumentationTrait.class)
.map(DocumentationTrait::getValue)
.map(docs -> {
writeDocs(docs);
return true;
}).orElse(false);
Optional stringOptional = member.getMemberTrait(model, MediaTypeTrait.class)
.map(StringTrait::getValue);
if (stringOptional.isPresent()) {
if (hasDocs) {
writeDocs("");
}
writeDocs("This value conforms to the media type: " + stringOptional.get());
hasDocs = true;
}
GoUsageIndex usageIndex = GoUsageIndex.of(model);
if (usageIndex.isUsedForOutput(member)) {
if (member.getMemberTrait(model,
HttpPrefixHeadersTrait.class).isPresent()) {
if (hasDocs) {
writeDocs("");
}
writeDocs("Map keys will be normalized to lower-case.");
hasDocs = true;
}
}
if (member.getMemberTrait(model, RequiredTrait.class).isPresent()) {
if (hasDocs) {
writeDocs("");
}
writeDocs("This member is required.");
hasDocs = true;
}
Optional deprecatedTrait = member.getMemberTrait(model, DeprecatedTrait.class);
if (member.getTrait(DeprecatedTrait.class).isPresent() || isTargetDeprecated(model, member)) {
if (hasDocs) {
writeDocs("");
}
final String defaultMessage = "This member has been deprecated.";
String message = defaultMessage;
if (deprecatedTrait.isPresent()) {
message = deprecatedTrait.get().getMessage().map(s -> {
if (s.length() == 0) {
return defaultMessage;
}
return s;
}).orElse(defaultMessage);
}
writeDocs("Deprecated: " + message);
}
return hasDocs;
}
private boolean isTargetDeprecated(Model model, MemberShape member) {
return model.expectShape(member.getTarget()).getTrait(DeprecatedTrait.class).isPresent()
// don't consider deprecated prelude shapes (like PrimitiveBoolean)
&& !Prelude.isPreludeShape(member.getTarget());
}
public void write(Writable w) {
write("$W", w);
}
public GoWriter addBuildTag(String tag) {
buildTags.add(tag);
return this;
}
@Override
public String toString() {
String contents = super.toString();
if (innerWriter) {
return contents;
}
var tags = buildTags.isEmpty()
? ""
: "//go:build " + String.join(",", buildTags) + "\n";
String[] packageParts = fullPackageName.split("/");
String header = String.format("// Code generated by smithy-go-codegen DO NOT EDIT.%n%n");
String packageName = packageParts[packageParts.length - 1];
if (packageName.startsWith("v") && packageParts.length >= 2) {
String remaining = packageName.substring(1);
try {
int value = Integer.parseInt(remaining);
packageName = packageParts[packageParts.length - 2];
if (value == 0 || value == 1) {
throw new CodegenException("module paths vN version component must only be N >= 2");
}
} catch (NumberFormatException ne) {
// Do nothing
}
}
String packageDocs = this.packageDocs.toString();
String packageStatement = String.format("package %s%n%n", packageName);
String importString = getImportContainer().toString();
String strippedContents = StringUtils.stripStart(contents, null);
String strippedImportString = StringUtils.strip(importString, null);
// Don't add an additional new line between explicit imports and managed imports.
if (!strippedImportString.isEmpty() && strippedContents.startsWith("import ")) {
return header + strippedImportString + "\n" + strippedContents;
}
return header + packageDocs + tags + packageStatement + importString + contents;
}
/**
* Implements Go symbol formatting for the {@code $T} formatter.
*/
private class GoSymbolFormatter implements BiFunction {
@Override
public String apply(Object type, String indent) {
if (type instanceof Symbol) {
Symbol resolvedSymbol = (Symbol) type;
String literal = resolvedSymbol.getName();
boolean isSlice = resolvedSymbol.getProperty(SymbolUtils.GO_SLICE, Boolean.class).orElse(false);
boolean isMap = resolvedSymbol.getProperty(SymbolUtils.GO_MAP, Boolean.class).orElse(false);
if (isSlice || isMap) {
resolvedSymbol = resolvedSymbol.getProperty(SymbolUtils.GO_ELEMENT_TYPE, Symbol.class)
.orElseThrow(() -> new CodegenException("Expected go element type property to be defined"));
literal = new PointableGoSymbolFormatter().apply(resolvedSymbol, "nested");
} else if (!SymbolUtils.isUniverseType(resolvedSymbol)
&& isExternalNamespace(resolvedSymbol.getNamespace())) {
literal = formatWithNamespace(resolvedSymbol);
}
addUseImports(resolvedSymbol);
if (isSlice) {
return "[]" + literal;
} else if (isMap) {
return "map[string]" + literal;
} else {
return literal;
}
} else if (type instanceof SymbolReference) {
SymbolReference typeSymbol = (SymbolReference) type;
addImport(typeSymbol.getSymbol(), typeSymbol.getAlias(), SymbolReference.ContextOption.USE);
return typeSymbol.getAlias();
} else {
throw new CodegenException(
"Invalid type provided to $T. Expected a Symbol, but found `" + type + "`");
}
}
private String formatWithNamespace(Symbol symbol) {
if (StringUtils.isEmpty(symbol.getNamespace())) {
return symbol.getName();
}
return String.format("%s.%s", CodegenUtils.getSymbolNamespaceAlias(symbol), symbol.getName());
}
}
/**
* Implements Go symbol formatting for the {@code $P} formatter. This is identical to the $T
* formatter, except that it will add a * to symbols that can be pointers.
*/
private final class PointableGoSymbolFormatter extends GoSymbolFormatter {
@Override
public String apply(Object type, String indent) {
String formatted = super.apply(type, indent);
if (isPointer(type)) {
formatted = "*" + formatted;
}
return formatted;
}
private boolean isPointer(Object type) {
if (type instanceof Symbol) {
Symbol typeSymbol = (Symbol) type;
return typeSymbol.getProperty(SymbolUtils.POINTABLE, Boolean.class).orElse(false);
} else if (type instanceof SymbolReference) {
SymbolReference typeSymbol = (SymbolReference) type;
return typeSymbol.getProperty(SymbolUtils.POINTABLE, Boolean.class).orElse(false)
|| typeSymbol.getSymbol().getProperty(SymbolUtils.POINTABLE, Boolean.class).orElse(false);
} else {
throw new CodegenException(
"Invalid type provided to $P. Expected a Symbol, but found `" + type + "`");
}
}
}
private final class GoWritableInjector extends GoSymbolFormatter {
@Override
public String apply(Object type, String indent) {
if (!(type instanceof Writable)) {
throw new CodegenException(
"expect Writable for GoWriter W injector, but got " + type);
}
var innerWriter = new GoWriter(fullPackageName, true);
((Writable) type).accept(innerWriter);
addImports(innerWriter);
addDependencies(innerWriter);
return innerWriter.toString().trim();
}
}
/**
* Implements Go symbol formatting for the {@code $D} formatter.
*/
private final class GoDependencyFormatter implements BiFunction {
@Override
public String apply(Object type, String indent) {
if (type instanceof GoDependency) {
addUseImports((GoDependency) type);
} else {
throw new CodegenException(
"Invalid type provided to $D. Expected a GoDependency, but found `" + type + "`");
}
return "";
}
}
public interface Writable extends Consumer {
}
/**
* Chains together multiple Writables that can be composed into one Writable.
*/
public static final class ChainWritable {
private final List writables;
public ChainWritable() {
writables = new ArrayList<>();
}
public static ChainWritable of(GoWriter.Writable... writables) {
var chain = new ChainWritable();
chain.writables.addAll(ListUtils.of(writables));
return chain;
}
public static ChainWritable of(Collection writables) {
var chain = new ChainWritable();
chain.writables.addAll(writables);
return chain;
}
public boolean isEmpty() {
return writables.isEmpty();
}
public ChainWritable add(GoWriter.Writable writable) {
writables.add(writable);
return this;
}
public ChainWritable add(Optional value, Function fn) {
value.ifPresent(t -> writables.add(fn.apply(t)));
return this;
}
public ChainWritable add(boolean include, GoWriter.Writable writable) {
if (!include) {
writables.add(writable);
}
return this;
}
public GoWriter.Writable compose(boolean writeNewlines) {
return (GoWriter writer) -> {
var hasPrevious = false;
for (GoWriter.Writable writable : writables) {
if (hasPrevious && writeNewlines) {
writer.write("");
}
hasPrevious = true;
writer.write("$W", writable);
}
};
}
public GoWriter.Writable compose() {
return compose(true);
}
}
}
ImportDeclarations.java 0000664 0000000 0000000 00000006564 15102203672 0036146 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.Map;
import java.util.TreeMap;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.ImportContainer;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.utils.StringUtils;
/**
* Container and formatter for go imports.
*/
final class ImportDeclarations implements ImportContainer {
private final String packageName;
private final Map imports = new TreeMap<>();
ImportDeclarations(String packageName) {
this.packageName = packageName;
}
public void addImport(String importPath, String alias) {
if (importPath.isBlank() || importPath.equals(packageName)) {
return; // either a universe type or something from the local package
}
String importAlias = CodegenUtils.getDefaultPackageImportName(importPath);
if (!StringUtils.isBlank(alias)) {
if (alias.equals(".")) {
// Global imports are generally a bad practice.
throw new CodegenException("Globally importing packages is forbidden: " + importPath);
}
importAlias = alias;
}
// Ensure that multiple packages cannot be imported with the same name.
if (imports.containsKey(importAlias) && !imports.get(importAlias).equals(importPath)) {
throw new CodegenException("Import name collision: " + importAlias
+ ". Previous: " + imports.get(importAlias) + "New: " + importPath);
}
imports.putIfAbsent(importAlias, importPath);
}
public void addImports(ImportDeclarations other) {
other.imports.forEach((importAlias, importPath) -> {
addImport(importPath, importAlias);
});
}
@Override
public void importSymbol(Symbol symbol, String alias) {
if (!symbol.getNamespace().isBlank()) { // e.g. a universe type like string
addImport(symbol.getNamespace(), alias);
}
}
@Override
public String toString() {
if (imports.isEmpty()) {
return "";
}
StringBuilder builder = new StringBuilder("import (\n");
for (Map.Entry entry : imports.entrySet()) {
builder.append('\t');
builder.append(createImportStatement(entry));
builder.append('\n');
}
builder.append(")\n\n");
return builder.toString();
}
private String createImportStatement(Map.Entry entry) {
String formattedPackageName = "\"" + entry.getValue() + "\"";
return CodegenUtils.getDefaultPackageImportName(entry.getValue()).equals(entry.getKey())
? formattedPackageName
: entry.getKey() + " " + formattedPackageName;
}
}
IntEnumGenerator.java 0000664 0000000 0000000 00000011317 15102203672 0035561 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.LinkedHashSet;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.model.shapes.IntEnumShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.traits.DocumentationTrait;
import software.amazon.smithy.model.traits.EnumValueTrait;
import software.amazon.smithy.utils.SmithyInternalApi;
import software.amazon.smithy.utils.StringUtils;
/**
* Renders intEnums and their constants.
*/
@SmithyInternalApi
public final class IntEnumGenerator implements Runnable {
private static final Logger LOGGER = Logger.getLogger(IntEnumGenerator.class.getName());
private final SymbolProvider symbolProvider;
private final GoWriter writer;
private final IntEnumShape shape;
public IntEnumGenerator(SymbolProvider symbolProvider, GoWriter writer, IntEnumShape shape) {
this.symbolProvider = symbolProvider;
this.writer = writer;
this.shape = shape;
}
@Override
public void run() {
Symbol symbol = symbolProvider.toSymbol(shape);
// TODO(smithy): Use type alias instead of type definition until refactoring
// protocol generators is prioritized.
writer.write("type $L = int32", symbol.getName()).write("");
writer.writeDocs(String.format("Enum values for %s", symbol.getName()));
Set constants = new LinkedHashSet<>();
writer.openBlock("const (", ")", () -> {
for (Map.Entry entry : shape.getAllMembers().entrySet()) {
StringBuilder labelBuilder = new StringBuilder(symbol.getName());
String name = entry.getKey();
for (String part : name.split("(?U)[\\W_]")) {
if (part.matches(".*[a-z].*") && part.matches(".*[A-Z].*")) {
// Mixed case names should not be changed other than first letter capitalized.
labelBuilder.append(StringUtils.capitalize(part));
} else {
// For all non-mixed case parts title case first letter, followed by all other lower cased.
labelBuilder.append(StringUtils.capitalize(part.toLowerCase(Locale.US)));
}
}
String label = labelBuilder.toString();
// If camel-casing would cause a conflict, don't camel-case this enum value.
if (constants.contains(label)) {
LOGGER.warning(String.format(
"Multiple enums resolved to the same name, `%s`, using unaltered value for: %s",
label, name));
label = name;
}
constants.add(label);
entry.getValue().getTrait(DocumentationTrait.class)
.ifPresent(trait -> writer.writeDocs(trait.getValue()));
writer.write("$L $L = $L", label, symbol.getName(),
entry.getValue().expectTrait(EnumValueTrait.class).expectIntValue());
}
}).write("");
// TODO(smithy): type aliases don't allow defining methods on base types (e.g. int32).
// Uncomment generating the Value() method when the type alias is migrated to type definition.
/*
writer.writeDocs(String.format("Values returns all known values for %s. Note that this can be expanded in the "
+ "future, and so it is only as up to date as the client.%n%nThe ordering of this slice is not "
+ "guaranteed to be stable across updates.", symbol.getName()));
writer.openBlock("func ($L) Values() []$L {", "}", symbol.getName(), symbol.getName(), () -> {
writer.openBlock("return []$L{", "}", symbol.getName(), () -> {
for (Map.Entry entry : shape.getEnumValues().entrySet()) {
writer.write("$L,", entry.getValue());
}
});
});
*/
}
}
ManifestWriter.java 0000664 0000000 0000000 00000014400 15102203672 0035272 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import software.amazon.smithy.build.FileManifest;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.node.ArrayNode;
import software.amazon.smithy.model.node.BooleanNode;
import software.amazon.smithy.model.node.Node;
import software.amazon.smithy.model.node.ObjectNode;
import software.amazon.smithy.model.node.StringNode;
import software.amazon.smithy.model.traits.UnstableTrait;
import software.amazon.smithy.utils.SmithyBuilder;
import software.amazon.smithy.utils.SmithyInternalApi;
/**
* Generates a manifest description of the generated code, minimum go version,
* and minimum dependencies required.
*/
@SmithyInternalApi
public final class ManifestWriter {
private static final Logger LOGGER = Logger.getLogger(ManifestWriter.class.getName());
private static final String GENERATED_JSON = "generated.json";
private final String moduleName;
private final FileManifest fileManifest;
private final GoModuleInfo goModuleInfo;
private final boolean isUnstable;
private ManifestWriter(Builder builder) {
moduleName = SmithyBuilder.requiredState("moduleName", builder.moduleName);
fileManifest = SmithyBuilder.requiredState("fileManifest", builder.fileManifest);
goModuleInfo = SmithyBuilder.requiredState("goModuleInfo", builder.goModuleInfo);
isUnstable = builder.isUnstable;
}
/**
* Write the manifest description of the Smithy model based generated source code.
*
* @param settings the go settings
* @param model the smithy model
* @param fileManifest the file manifest
* @param goModuleInfo the go module info
*/
public static void writeManifest(
GoSettings settings,
Model model,
FileManifest fileManifest,
GoModuleInfo goModuleInfo
) {
builder()
.moduleName(settings.getModuleName())
.fileManifest(fileManifest)
.goModuleInfo(goModuleInfo)
.isUnstable(settings.getService(model).getTrait(UnstableTrait.class).isPresent())
.build()
.writeManifest();
}
/**
* Write the manifest description of the generated code.
*/
public void writeManifest() {
Path manifestFile = fileManifest.getBaseDir().resolve(GENERATED_JSON);
if (Files.exists(manifestFile)) {
try {
Files.delete(manifestFile);
} catch (IOException e) {
throw new CodegenException("Failed to delete existing " + GENERATED_JSON + " file", e);
}
}
fileManifest.addFile(manifestFile);
LOGGER.fine("Creating manifest at path " + manifestFile.toString());
Node generatedJson = buildManifestFile();
fileManifest.writeFile(manifestFile.toString(), Node.prettyPrintJson(generatedJson) + "\n");
}
private Node buildManifestFile() {
Map dependencyNodes = gatherDependencyNodes(goModuleInfo.getMinimumNonStdLibDependencies());
Collection generatedFiles = gatherGeneratedFiles(fileManifest);
return ObjectNode.objectNode(Map.of(
StringNode.from("module"), StringNode.from(moduleName),
StringNode.from("go"), StringNode.from(goModuleInfo.getGoDirective()),
StringNode.from("dependencies"), ObjectNode.objectNode(dependencyNodes),
StringNode.from("files"), ArrayNode.fromStrings(generatedFiles),
StringNode.from("unstable"), BooleanNode.from(isUnstable)
)).withDeepSortedKeys();
}
private Map gatherDependencyNodes(Map dependencies) {
Map dependencyNodes = new HashMap<>();
for (Map.Entry entry : dependencies.entrySet()) {
dependencyNodes.put(StringNode.from(entry.getKey()), StringNode.from(entry.getValue()));
}
return dependencyNodes;
}
private static Collection gatherGeneratedFiles(FileManifest fileManifest) {
Collection generatedFiles = new ArrayList<>();
Path baseDir = fileManifest.getBaseDir();
for (Path filePath : fileManifest.getFiles()) {
generatedFiles.add(baseDir.relativize(filePath).toString());
}
generatedFiles = generatedFiles.stream().sorted().collect(Collectors.toList());
return generatedFiles;
}
public static Builder builder() {
return new Builder();
}
public static class Builder implements SmithyBuilder {
private String moduleName;
private FileManifest fileManifest;
private GoModuleInfo goModuleInfo;
private boolean isUnstable;
public Builder moduleName(String moduleName) {
this.moduleName = moduleName;
return this;
}
public Builder fileManifest(FileManifest fileManifest) {
this.fileManifest = fileManifest;
return this;
}
public Builder goModuleInfo(GoModuleInfo goModuleInfo) {
this.goModuleInfo = goModuleInfo;
return this;
}
public Builder isUnstable(boolean isUnstable) {
this.isUnstable = isUnstable;
return this;
}
@Override
public ManifestWriter build() {
return new ManifestWriter(this);
}
}
}
MiddlewareIdentifier.java 0000664 0000000 0000000 00000010636 15102203672 0036416 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.Objects;
import java.util.Optional;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.utils.SmithyBuilder;
/**
* A String or Go Symbol of type string used for middleware to identify themselves by.
*/
public final class MiddlewareIdentifier {
private final String string;
private final Symbol symbol;
private MiddlewareIdentifier(Builder builder) {
if ((Objects.isNull(builder.string) && Objects.isNull(builder.symbol))) {
throw new IllegalStateException("string or symbol must be provided");
}
if ((!Objects.isNull(builder.string) && !Objects.isNull(builder.symbol))) {
throw new IllegalStateException("either string or symbol must be provided, not both");
}
string = builder.string;
symbol = builder.symbol;
}
public Optional getString() {
return Optional.ofNullable(string);
}
public Optional getSymbol() {
return Optional.ofNullable(symbol);
}
public void writeInline(GoWriter writer) {
if (getSymbol().isPresent()) {
writer.writeInline("$T", getSymbol().get());
} else if (getString().isPresent()) {
writer.writeInline("$S", getString().get());
} else {
throw new CodegenException("unsupported identifier state");
}
}
public static MiddlewareIdentifier symbol(Symbol symbol) {
return builder().symbol(symbol).build();
}
public static MiddlewareIdentifier string(String string) {
return builder().name(string).build();
}
@Override
public String toString() {
if (symbol != null) {
return symbol.toString();
} else if (string != null) {
return string;
} else {
throw new CodegenException("unexpected identifier state");
}
}
public static Builder builder() {
return new Builder();
}
@Override
public int hashCode() {
return Objects.hash(string, symbol);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (!(o instanceof MiddlewareIdentifier)) {
return false;
}
MiddlewareIdentifier identifier = (MiddlewareIdentifier) o;
return Objects.equals(string, identifier.string)
&& ((symbol == identifier.symbol)
|| (symbol != null && identifier.symbol != null
&& symbol.getNamespace().equals(identifier.symbol.getNamespace())
&& symbol.getName().equals(identifier.symbol.getName())));
}
/**
* A builder for {@link MiddlewareIdentifier}.
*/
public static class Builder implements SmithyBuilder {
private String string;
private Symbol symbol;
public Builder name(String name) {
this.string = name;
return this;
}
public Builder symbol(Symbol symbol) {
this.symbol = symbol;
return this;
}
@Override
public MiddlewareIdentifier build() {
return new MiddlewareIdentifier(this);
}
}
}
OperationGenerator.java 0000664 0000000 0000000 00000031432 15102203672 0036142 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.endpoints.EndpointParameterOperationBindingsGenerator;
import software.amazon.smithy.go.codegen.integration.MiddlewareRegistrar;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.OperationIndex;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.traits.DeprecatedTrait;
import software.amazon.smithy.model.traits.StreamingTrait;
import software.amazon.smithy.rulesengine.traits.EndpointRuleSetTrait;
/**
* Generates a client operation and associated custom shapes.
*/
public final class OperationGenerator implements Runnable {
private final GoCodegenContext ctx;
private final Model model;
private final SymbolProvider symbolProvider;
private final GoWriter writer;
private final ServiceShape service;
private final OperationShape operation;
private final Symbol operationSymbol;
private final ProtocolGenerator protocolGenerator;
private final List runtimeClientPlugins;
OperationGenerator(
GoCodegenContext ctx,
GoWriter writer,
OperationShape operation,
ProtocolGenerator protocolGenerator,
List runtimeClientPlugins
) {
this.ctx = ctx;
this.model = ctx.model();
this.symbolProvider = ctx.symbolProvider();
this.writer = writer;
this.service = ctx.settings().getService(ctx.model());
this.operation = operation;
this.operationSymbol = ctx.symbolProvider().toSymbol(operation);
this.protocolGenerator = protocolGenerator;
this.runtimeClientPlugins = runtimeClientPlugins;
}
@Override
public void run() {
OperationIndex operationIndex = OperationIndex.of(model);
Symbol serviceSymbol = symbolProvider.toSymbol(service);
if (!operationIndex.getInput(operation).isPresent()) {
// Theoretically this shouldn't ever get hit since we automatically insert synthetic inputs / outputs.
throw new CodegenException(
"Operations are required to have input shapes in order to allow for future evolution.");
}
StructureShape inputShape = operationIndex.getInput(operation).get();
Symbol inputSymbol = symbolProvider.toSymbol(inputShape);
if (!operationIndex.getOutput(operation).isPresent()) {
throw new CodegenException(
"Operations are required to have output shapes in order to allow for future evolution.");
}
StructureShape outputShape = operationIndex.getOutput(operation).get();
Symbol outputSymbol = symbolProvider.toSymbol(outputShape);
// Generate operation method
final boolean hasDocs = writer.writeShapeDocs(operation);
operation.getTrait(DeprecatedTrait.class)
.ifPresent(trait -> {
if (hasDocs) {
writer.writeDocs("");
}
final String defaultMessage = "This operation has been deprecated.";
writer.writeDocs("Deprecated: " + trait.getMessage().map(s -> {
if (s.length() == 0) {
return defaultMessage;
}
return s;
}).orElse(defaultMessage));
});
Symbol contextSymbol = SymbolUtils.createValueSymbolBuilder("Context", SmithyGoDependency.CONTEXT).build();
writer.openBlock("func (c $P) $T(ctx $T, params $P, optFns ...func(*Options)) ($P, error) {", "}",
serviceSymbol, operationSymbol, contextSymbol, inputSymbol, outputSymbol, () -> {
writer.write("if params == nil { params = &$T{} }", inputSymbol);
writer.write("");
writer.write("result, metadata, err := c.invokeOperation(ctx, $S, params, optFns, c.$L)",
operationSymbol.getName(), getAddOperationMiddlewareFuncName(operationSymbol));
writer.write("if err != nil { return nil, err }");
writer.write("");
writer.write("out := result.($P)", outputSymbol);
writer.write("out.ResultMetadata = metadata");
writer.write("return out, nil");
}).write("");
// Write out the input and output structures. These are written out here to prevent naming conflicts with other
// shapes in the model.
new StructureGenerator(model, symbolProvider, writer, service, inputShape, inputSymbol, protocolGenerator)
.renderStructure(() -> {
}, true);
var rulesTrait = service.getTrait(EndpointRuleSetTrait.class);
if (rulesTrait.isPresent()) {
writer.write(new EndpointParameterOperationBindingsGenerator(ctx, operation, inputShape)
.generate());
}
// The output structure gets a metadata member added.
Symbol metadataSymbol = SymbolUtils.createValueSymbolBuilder("Metadata", SmithyGoDependency.SMITHY_MIDDLEWARE)
.build();
boolean hasEventStream = Stream.concat(inputShape.members().stream(),
outputShape.members().stream())
.anyMatch(memberShape -> StreamingTrait.isEventStream(model, memberShape));
new StructureGenerator(model, symbolProvider, writer, service, outputShape, outputSymbol, protocolGenerator)
.renderStructure(() -> {
if (outputShape.getMemberNames().size() != 0) {
writer.write("");
}
if (hasEventStream) {
writer.write("eventStream $P",
EventStreamGenerator.getEventStreamOperationStructureSymbol(service, operation))
.write("");
}
writer.writeDocs("Metadata pertaining to the operation's result.");
writer.write("ResultMetadata $T", metadataSymbol);
});
if (hasEventStream) {
writer.write("""
// GetStream returns the type to interact with the event stream.
func (o $P) GetStream() $P {
return o.eventStream
}
""", outputSymbol, EventStreamGenerator.getEventStreamOperationStructureSymbol(
service, operation));
}
// Generate operation protocol middleware helper function
generateAddOperationMiddleware();
}
/**
* Adds middleware to the operation middleware stack.
*/
private void generateAddOperationMiddleware() {
Symbol stackSymbol = SymbolUtils.createPointableSymbolBuilder("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE)
.build();
writer.openBlock("func (c *Client) $L(stack $P, options Options) (err error) {", "}",
getAddOperationMiddlewareFuncName(operationSymbol), stackSymbol,
() -> {
generateOperationProtocolMiddlewareAdders();
// Populate middleware's from runtime client plugins
runtimeClientPlugins.forEach(runtimeClientPlugin -> {
if (!runtimeClientPlugin.matchesService(model, service)
&& !runtimeClientPlugin.matchesOperation(model, service, operation)) {
return;
}
if (!runtimeClientPlugin.registerMiddleware().isPresent()) {
return;
}
MiddlewareRegistrar middlewareRegistrar = runtimeClientPlugin.registerMiddleware().get();
Collection functionArguments = middlewareRegistrar.getFunctionArguments();
if (middlewareRegistrar.getInlineRegisterMiddlewareStatement() != null) {
String registerStatement = String.format("if err = stack.%s",
middlewareRegistrar.getInlineRegisterMiddlewareStatement());
writer.writeInline(registerStatement);
writer.writeInline("$T(", middlewareRegistrar.getResolvedFunction());
if (functionArguments != null) {
List args = new ArrayList<>(functionArguments);
for (Symbol arg : args) {
writer.writeInline("$P, ", arg);
}
}
writer.writeInline(")");
writer.write(", $T); err != nil {\nreturn err\n}",
middlewareRegistrar.getInlineRegisterMiddlewarePosition());
} else {
writer.writeInline("if err = $T(stack", middlewareRegistrar.getResolvedFunction());
if (functionArguments != null) {
List args = new ArrayList<>(functionArguments);
for (Symbol arg : args) {
writer.writeInline(", $P", arg);
}
}
writer.write("); err != nil {\nreturn err\n}");
}
});
writer.write("return nil");
});
}
/**
* Generate operation protocol middleware helper.
*/
private void generateOperationProtocolMiddlewareAdders() {
if (protocolGenerator == null) {
return;
}
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
// persist operation input to context for internal build/finalize middleware access
writer.write("""
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}""");
// Add request serializer middleware
String serializerMiddlewareName = ProtocolGenerator.getSerializeMiddlewareName(
operation.getId(), service, protocolGenerator.getProtocolName());
writer.write("err = stack.Serialize.Add(&$L{}, middleware.After)", serializerMiddlewareName);
writer.write("if err != nil { return err }");
// Adds response deserializer middleware
String deserializerMiddlewareName = ProtocolGenerator.getDeserializeMiddlewareName(
operation.getId(), service, protocolGenerator.getProtocolName());
writer.write("err = stack.Deserialize.Add(&$L{}, middleware.After)", deserializerMiddlewareName);
writer.write("if err != nil { return err }");
// FUTURE: retry middleware should be at the front of finalize, right now it's added by the SDK
writer.write("""
if err := addProtocolFinalizerMiddlewares(stack, options, $S); err != nil {
return $T("add protocol finalizers: %v", err)
}""",
operationSymbol.getName(),
GoStdlibTypes.Fmt.Errorf);
writer.write("");
}
/**
* Returns the name of the operation's middleware mutator function, that adds all middleware for the operation to
* the stack.
*
* @param operation symbol for operation
* @return name of function
*/
public static String getAddOperationMiddlewareFuncName(Symbol operation) {
return String.format("addOperation%sMiddlewares", operation.getName());
}
}
ProtocolDocumentGenerator.java 0000664 0000000 0000000 00000052545 15102203672 0037512 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.function.Consumer;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.selector.Selector;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.utils.IoUtils;
/**
* Generates the service's internal and external document Go packages. The document packages contain the service
* specific document Interface definition, protocol specific document marshaler and unmarshaller implementations for
* that interface, and constructors for creating service document types.
*/
public final class ProtocolDocumentGenerator {
public static final String DOCUMENT_INTERFACE_NAME = "Interface";
public static final String NO_DOCUMENT_SERDE_TYPE_NAME = "noSmithyDocumentSerde";
public static final String NEW_LAZY_DOCUMENT = "NewLazyDocument";
public static final String INTERNAL_NEW_DOCUMENT_MARSHALER_FUNC = "NewDocumentMarshaler";
public static final String INTERNAL_NEW_DOCUMENT_UNMARSHALER_FUNC = "NewDocumentUnmarshaler";
public static final String INTERNAL_IS_DOCUMENT_INTERFACE = "IsInterface";
public static final String UNMARSHAL_SMITHY_DOCUMENT_METHOD = "UnmarshalSmithyDocument";
public static final String MARSHAL_SMITHY_DOCUMENT_METHOD = "MarshalSmithyDocument";
private static final String SERVICE_SMITHY_DOCUMENT_INTERFACE = "smithyDocument";
private static final String IS_SMITHY_DOCUMENT_METHOD = "isSmithyDocument";
private final GoSettings settings;
private final GoDelegator delegator;
private final Model model;
private final boolean hasDocumentShapes;
public ProtocolDocumentGenerator(
GoSettings settings,
Model model,
GoDelegator delegator
) {
this.settings = settings;
this.model = model;
this.delegator = delegator;
ShapeId serviceId = settings.getService().toShapeId();
this.hasDocumentShapes = Selector.parse(String.format("[service = %s] ~> document", serviceId))
.matches(model).findAny()
.isPresent();
}
/**
* Generates any required client types or functions to support protocol document types.
*/
public void generateDocumentSupport() {
generateNoSerdeType();
generateInternalDocumentInterface();
generateDocumentPackage();
}
/**
* Generates the publicly accessible service document package. This package contains a type alias definition
* for document interface, as well as a constructor function for creating a document marshaller.
*
* This package is not generated if the service does not have any document shapes in the model.
*
*
{@code
* // /document
* package document
*
* import (
* internaldocument "/internal/document"
* )
*
* type Interface = internaldocument.Interface
*
* func NewLazyDocument(v interface{}) Interface {
* return internaldocument.NewDocumentMarshaler(v)
* }
* }
*/
private void generateDocumentPackage() {
if (!this.hasDocumentShapes) {
return;
}
writeDocumentPackage("doc.go", writer -> {
String documentTemplate = IoUtils.readUtf8Resource(getClass(), "document_doc.go.template");
writer.writeRawPackageDocs(documentTemplate);
});
writeDocumentPackage("document.go", writer -> {
writer.writeDocs(String.format("%s defines a document which is a protocol-agnostic type which supports a "
+ "JSON-like data-model. You can use this type to send UTF-8 strings, arbitrary precision "
+ "numbers, booleans, nulls, a list of these values, and a map of UTF-8 strings to these "
+ "values.", DOCUMENT_INTERFACE_NAME));
writer.writeDocs("");
writer.writeDocs(String.format("You create a document type using the %s function and passing it the Go "
+ "type to marshal. When receiving a document in an API response, you use the "
+ "document's UnmarshalSmithyDocument function to decode the response to your desired Go "
+ "type. Unless documented specifically generated structure types in client packages or "
+ "client types packages are not supported at this time. Such types embed a "
+ "noSmithyDocumentSerde and will cause an error to be returned when attempting to send an "
+ "API request.", NEW_LAZY_DOCUMENT));
writer.writeDocs("");
writer.writeDocs("For more information see the accompanying package documentation and linked references.");
writer.write("type $L = $T", DOCUMENT_INTERFACE_NAME,
getInternalDocumentSymbol(DOCUMENT_INTERFACE_NAME))
.write("");
writer.writeDocs(String.format("You create document type using the %s function and passing it the Go "
+ "type to be marshaled and sent to the service. The document marshaler supports semantics similar "
+ "to the encoding/json Go standard library.", NEW_LAZY_DOCUMENT));
writer.writeDocs("");
writer.writeDocs("For more information see the accompanying package documentation and linked references.");
writer.openBlock("func $L(v interface{}) $T {", "}", NEW_LAZY_DOCUMENT,
getDocumentSymbol(DOCUMENT_INTERFACE_NAME), () -> {
writer.write("return $T(v)",
getInternalDocumentSymbol(INTERNAL_NEW_DOCUMENT_MARSHALER_FUNC));
})
.write("");
});
}
/**
* Generates an unexported type alias for the {@code github.com/aws/smithy-go/document#NoSerde} type in both the
* service and types package. This allows for this type to be used as an embedded member in structures to
* prevent usage of generated Smithy structure shapes as document types. Additionally, since the member is
* unexported this prevents the need de-conflict naming collisions.
*
* These type aliases are always generated regardless of whether there are document shapes present in the model
* or not.
*
*
{@code
* package types
*
* type noSmithyDocumentSerde = smithydocument.NoSerde
*
* type ExampleStructureShape struct {
* FieldOne *string
*
* noSmithyDocumentSerde
* }
*
* }
*/
private void generateNoSerdeType() {
Symbol noSerde = SymbolUtils.createValueSymbolBuilder("NoSerde",
SmithyGoDependency.SMITHY_DOCUMENT).build();
delegator.useShapeWriter(settings.getService(model), writer -> {
writer.write("type $L = $T", NO_DOCUMENT_SERDE_TYPE_NAME, noSerde);
});
delegator.useFileWriter("./types/types.go", settings.getModuleName() + "/types", writer -> {
writer.write("type $L = $T", NO_DOCUMENT_SERDE_TYPE_NAME, noSerde);
});
}
/**
* Generates the document interface definition in the internal document package.
*
* {@code
* import smithydocument "github.com/aws/smithy-go/document"
*
* type smithyDocument interface {
* isSmithyDocument()
* }
*
* type Interface interface {
* smithydocument.Marshaler
* smithydocument.Unmarshaler
* smithyDocument
* }
* }
*/
private void generateInternalDocumentInterface() {
if (!this.hasDocumentShapes) {
return;
}
Symbol serviceSmithyDocumentInterface = getInternalDocumentSymbol(SERVICE_SMITHY_DOCUMENT_INTERFACE);
Symbol internalDocumentInterface = getInternalDocumentSymbol(DOCUMENT_INTERFACE_NAME);
Symbol smithyDocumentMarshaler = SymbolUtils.createValueSymbolBuilder("Marshaler",
SmithyGoDependency.SMITHY_DOCUMENT).build();
Symbol smithyDocumentUnmarshaler = SymbolUtils.createValueSymbolBuilder("Unmarshaler",
SmithyGoDependency.SMITHY_DOCUMENT).build();
writeInternalDocumentPackage("document.go", writer -> {
writer.writeDocs(String.format("%s is an interface which is used to bind"
+ " a document type to its service client.", serviceSmithyDocumentInterface));
writer.openBlock("type $T interface {", "}", serviceSmithyDocumentInterface,
() -> writer.write("$L()", IS_SMITHY_DOCUMENT_METHOD))
.write("");
writer.writeDocs(String.format("%s is a JSON-like data model type that is protocol agnostic and is used"
+ "to send open-content to a service.", internalDocumentInterface));
writer.openBlock("type $T interface {", "}", internalDocumentInterface, () -> {
writer.write("$T", serviceSmithyDocumentInterface);
writer.write("$T", smithyDocumentMarshaler);
writer.write("$T", smithyDocumentUnmarshaler);
}).write("");
});
writeInternalDocumentPackage("document_test.go", writer -> {
writer.write("var _ $T = ($P)(nil)",
serviceSmithyDocumentInterface, internalDocumentInterface);
writer.write("var _ $T = ($P)(nil)",
smithyDocumentMarshaler, internalDocumentInterface);
writer.write("var _ $T = ($P)(nil)",
smithyDocumentUnmarshaler,
internalDocumentInterface);
writer.write("");
});
}
/**
* Generates the internal document Go package for the service client. Delegates the logic for document marshaling
* and unmarshalling types to the provided protocol generator using the given context.
*
* Generate a document marshaler type for marshaling documents to the service's protocol document format.
*
*
{@code
* type documentMarshaler struct {
* value interface{}
* }
*
* func NewDocumentMarshaler(v interface{}) Interface {
* // default or protocol implementation
* }
*
* func (m *documentMarshaler) UnmarshalSmithyDocument(v interface{}) error {
* // implemented by protocol generator
* }
*
* func (m *documentUnmarshaler) MarshalSmithyDocument() ([]byte, error) {
* // implemented by protocol generator
* }
* }
*
* Generate a document marshaler type for unmarshalling documents from the service's protocol response to a Go
* type.
*
*
{@code
* type documentUnmarshaler struct {
* value interface{}
* }
* func NewDocumentUnmarshaler(v interface{}) Interface {
* // default or protocol implementation
* }
*
* func (m *documentUnmarshaler) UnmarshalSmithyDocument(v interface{}) error {
* // implemented by protocol generator
* }
*
* func (m *documentUnmarshaler) MarshalSmithyDocument() ([]byte, error) {
* // implemented by protocol generator
* }
* }
*
* Generate {@code IsInterface} function which is used to assert whether a given document type
* is a valid service protocol document type implementation.
*
*
{@code
* func IsInterface(v Interface) bool {
* // implementation
* }
* }
*
* @param protocolGenerator the protocol generator.
* @param context the protocol generator context.
*/
public void generateInternalDocumentTypes(ProtocolGenerator protocolGenerator, GenerationContext context) {
if (!this.hasDocumentShapes) {
return;
}
writeInternalDocumentPackage("document.go", writer -> {
Symbol marshalerSymbol = getInternalDocumentSymbol("documentMarshaler",
true);
Symbol unmarshalerSymbol = getInternalDocumentSymbol("documentUnmarshaler", true);
Symbol isDocumentInterface = getInternalDocumentSymbol(INTERNAL_IS_DOCUMENT_INTERFACE);
writeInternalDocumentImplementation(
writer,
marshalerSymbol,
() -> {
protocolGenerator.generateProtocolDocumentMarshalerUnmarshalDocument(context.toBuilder()
.writer(writer)
.build());
},
() -> {
protocolGenerator.generateProtocolDocumentMarshalerMarshalDocument(context.toBuilder()
.writer(writer)
.build());
});
writeInternalDocumentImplementation(writer,
unmarshalerSymbol,
() -> {
protocolGenerator.generateProtocolDocumentUnmarshalerUnmarshalDocument(context.toBuilder()
.writer(writer)
.build());
},
() -> {
protocolGenerator.generateProtocolDocumentUnmarshalerMarshalDocument(context.toBuilder()
.writer(writer)
.build());
});
Symbol documentInterfaceSymbol = getInternalDocumentSymbol(DOCUMENT_INTERFACE_NAME);
writer.writeDocs(String.format("%s creates a new document marshaler for the given input type",
INTERNAL_NEW_DOCUMENT_MARSHALER_FUNC));
writer.openBlock("func $L(v interface{}) $T {", "}", INTERNAL_NEW_DOCUMENT_MARSHALER_FUNC,
documentInterfaceSymbol, () -> {
protocolGenerator.generateNewDocumentMarshaler(context.toBuilder()
.writer(writer)
.build(), marshalerSymbol);
}).write("");
writer.writeDocs(String.format("%s creates a new document unmarshaler for the given service response",
INTERNAL_NEW_DOCUMENT_UNMARSHALER_FUNC));
writer.openBlock("func $L(v interface{}) $T {", "}", INTERNAL_NEW_DOCUMENT_UNMARSHALER_FUNC,
documentInterfaceSymbol, () -> {
protocolGenerator.generateNewDocumentUnmarshaler(context.toBuilder()
.writer(writer)
.build(), unmarshalerSymbol);
}).write("");
writer.writeDocs(String.format("%s returns whether the given Interface implementation is"
+ " a valid client implementation", isDocumentInterface));
writer.openBlock("func $T(v Interface) (ok bool) {", "}", isDocumentInterface, () -> {
writer.openBlock("defer func() {", "}()", () -> {
writer.openBlock("if err := recover(); err != nil {", "}", () -> writer.write("ok = false"));
});
writer.write("v.$L()", IS_SMITHY_DOCUMENT_METHOD);
writer.write("return true");
}).write("");
});
}
private void writeInternalDocumentImplementation(
GoWriter writer,
Symbol typeSymbol,
Runnable unmarshalMethodDefinition,
Runnable marshalMethodDefinition
) {
writer.openBlock("type $T struct {", "}", typeSymbol, () -> {
writer.write("value interface{}");
});
writer.write("");
writer.openBlock("func (m $P) $L(v interface{}) error {", "}", typeSymbol, UNMARSHAL_SMITHY_DOCUMENT_METHOD,
unmarshalMethodDefinition);
writer.write("");
writer.openBlock("func (m $P) $L() ([]byte, error) {", "}", typeSymbol, MARSHAL_SMITHY_DOCUMENT_METHOD,
marshalMethodDefinition);
writer.write("");
writer.write("func (m $P) $L() {}", typeSymbol, IS_SMITHY_DOCUMENT_METHOD);
writer.write("");
writer.write("var _ $T = ($P)(nil)", getInternalDocumentSymbol(DOCUMENT_INTERFACE_NAME, true), typeSymbol);
writer.write("");
}
private void writeDocumentPackage(String fileName, Consumer writerConsumer) {
delegator.useFileWriter(getDocumentFilePath(fileName), getDocumentPackage(), writerConsumer);
}
private void writeInternalDocumentPackage(String fileName, Consumer writerConsumer) {
delegator.useFileWriter(getInternalDocumentFilePath(fileName), getInternalDocumentPackage(), writerConsumer);
}
private String getInternalDocumentPackage() {
return Utilities.getInternalDocumentPackage(settings);
}
private String getDocumentPackage() {
return Utilities.getDocumentPackage(settings);
}
private String getInternalDocumentFilePath(String fileName) {
return "./internal/document/" + fileName;
}
private String getDocumentFilePath(String fileName) {
return "./document/" + fileName;
}
private Symbol getDocumentSymbol(String typeName) {
return getDocumentSymbol(typeName, false);
}
private Symbol getDocumentSymbol(String typeName, boolean pointable) {
return Utilities.getDocumentSymbolBuilder(settings, typeName, pointable).build();
}
private Symbol getInternalDocumentSymbol(String typeName) {
return getInternalDocumentSymbol(typeName, false);
}
private Symbol getInternalDocumentSymbol(String typeName, boolean pointable) {
return Utilities.getInternalDocumentSymbolBuilder(settings, typeName, pointable).build();
}
/**
* Collection of helper utility functions for creating references to the service client's internal
* and external document package types.
*/
public static final class Utilities {
/**
* Create a non-pointable {@link Symbol.Builder} for typeName in the service's document package.
*
* @param settings the Smithy Go settings.
* @param typeName the name of the Go type.
* @return the symbol builder.
*/
public static Symbol.Builder getDocumentSymbolBuilder(GoSettings settings, String typeName) {
return getDocumentSymbolBuilder(settings, typeName, false);
}
/**
* Create {@link Symbol.Builder} for typeName in the service's document package.
*
* @param settings the Smithy Go settings.
* @param typeName the name of the Go type.
* @param pointable whether typeName is pointable.
* @return the symbol builder.
*/
public static Symbol.Builder getDocumentSymbolBuilder(
GoSettings settings,
String typeName,
boolean pointable
) {
return pointable
? SymbolUtils.createPointableSymbolBuilder(typeName, getDocumentPackage(settings))
: SymbolUtils.createValueSymbolBuilder(typeName, getDocumentPackage(settings));
}
/**
* Create a non-pointable {@link Symbol.Builder} for typeName in the service's internal document package.
*
* @param settings the Smithy Go settings.
* @param typeName the name of the Go type.
* @return the symbol builder.
*/
public static Symbol.Builder getInternalDocumentSymbolBuilder(GoSettings settings, String typeName) {
return getInternalDocumentSymbolBuilder(settings, typeName, false);
}
/**
* Create {@link Symbol.Builder} for typeName in the service's internal document package.
*
* @param settings the Smithy Go settings.
* @param typeName the name of the Go type.
* @param pointable whether typeName is pointable.
* @return the symbol builder.
*/
public static Symbol.Builder getInternalDocumentSymbolBuilder(
GoSettings settings,
String typeName,
boolean pointable
) {
Symbol.Builder builder = pointable
? SymbolUtils.createPointableSymbolBuilder(typeName, getInternalDocumentPackage(settings))
: SymbolUtils.createValueSymbolBuilder(typeName, getInternalDocumentPackage(settings));
builder.putProperty(SymbolUtils.NAMESPACE_ALIAS, "internaldocument");
return builder;
}
private static String getInternalDocumentPackage(GoSettings settings) {
return settings.getModuleName() + "/internal/document";
}
private static String getDocumentPackage(GoSettings settings) {
return settings.getModuleName() + "/document";
}
}
}
SemanticVersion.java 0000664 0000000 0000000 00000025666 15102203672 0035460 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import java.util.Comparator;
import java.util.Objects;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import software.amazon.smithy.utils.SmithyBuilder;
/**
* A semantic version parser that allows for prefixes to be compatible with Go version tags.
*/
public final class SemanticVersion {
// Regular Expression from https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
private static final Pattern SEMVER_PATTERN = Pattern.compile("^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)"
+ "(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?"
+ "(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$");
private final String prefix;
private final int major;
private final int minor;
private final int patch;
private final String preRelease;
private final String build;
private SemanticVersion(Builder builder) {
prefix = builder.prefix;
major = builder.major;
minor = builder.minor;
patch = builder.patch;
preRelease = builder.preRelease;
build = builder.build;
}
/**
* The semantic version prefix present before the major version.
*
* @return the optional prefix
*/
public Optional getPrefix() {
return Optional.ofNullable(prefix);
}
/**
* The major version number.
*
* @return the major version
*/
public int getMajor() {
return major;
}
/**
* The minor version number.
*
* @return the minor version
*/
public int getMinor() {
return minor;
}
/**
* The patch version number.
*
* @return the patch version
*/
public int getPatch() {
return patch;
}
public Optional getPreRelease() {
return Optional.ofNullable(preRelease);
}
public Optional getBuild() {
return Optional.ofNullable(build);
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
if (getPrefix().isPresent()) {
builder.append(getPrefix().get());
}
builder.append(getMajor());
builder.append('.');
builder.append(getMinor());
builder.append('.');
builder.append(getPatch());
if (getPreRelease().isPresent()) {
builder.append('-');
builder.append(getPreRelease().get());
}
if (getBuild().isPresent()) {
builder.append('+');
builder.append(getBuild().get());
}
return builder.toString();
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
SemanticVersion that = (SemanticVersion) o;
return getMajor() == that.getMajor()
&& getMinor() == that.getMinor()
&& getPatch() == that.getPatch()
&& getPrefix().equals(that.getPrefix())
&& getPreRelease().equals(that.getPreRelease())
&& getBuild().equals(that.getBuild());
}
@Override
public int hashCode() {
return Objects.hash(getPrefix(), getMajor(), getMinor(), getPatch(), getPreRelease(), getBuild());
}
/**
* Parse a semantic version string into a {@link SemanticVersion}.
*
* @param version the semantic version string
* @return the SemanticVersion representing the parsed value
*/
public static SemanticVersion parseVersion(String version) {
char[] parseArr = version.toCharArray();
StringBuilder prefixBuilder = new StringBuilder();
int position = 0;
while (position < parseArr.length && !Character.isDigit(parseArr[position])) {
prefixBuilder.append(parseArr[position]);
position++;
}
String prefix = null;
if (prefixBuilder.length() > 0) {
prefix = prefixBuilder.toString();
}
Matcher matcher = SEMVER_PATTERN.matcher(version.substring(position));
if (!matcher.matches()) {
throw newInvalidSemanticVersion(version);
}
return builder()
.prefix(prefix)
.major(Integer.parseInt(matcher.group(1)))
.minor(Integer.parseInt(matcher.group(2)))
.patch(Integer.parseInt(matcher.group(3)))
.preRelease(matcher.group(4))
.build(matcher.group(5))
.build();
}
private static IllegalArgumentException newInvalidSemanticVersion(String version) {
return new IllegalArgumentException("Invalid semantic version string: " + version);
}
/**
* Get a {@link SemanticVersion} builder.
*
* @return the builder
*/
public static Builder builder() {
return new Builder();
}
/**
* Return a builder for this {@link SemanticVersion}.
*
* @return the builder
*/
public Builder toBuilder() {
return builder()
.prefix(this.prefix)
.major(this.major)
.minor(this.minor)
.patch(this.patch)
.preRelease(this.preRelease)
.build(this.build);
}
/**
* Compare two {@link SemanticVersion}, ignoring prefix strings. To validate that prefix strings match
* see the overloaded function signature.
*
* @param o the {@link SemanticVersion} to be compared.
* @return the value {@code 0} if this {@code SemanticVersion} is
* equal to the argument {@code SemanticVersion}; a value less than
* {@code 0} if this {@code SemanticVersion} is less
* than the argument {@code SemanticVersion}; and a value greater
* than {@code 0} if this {@code SemanticVersion} is
* greater than the argument {@code SemanticVersion}.
*/
public int compareTo(SemanticVersion o) {
return compareTo(o, (o1, o2) -> 0);
}
/**
* Compare two {@link SemanticVersion}, using the prefixComparator for comparing the prefix strings.
*
* @param o the {@link SemanticVersion} to be compared.
* @param prefixComparator the comparator for comparing prefixes
* @return the value {@code 0} if this {@code SemanticVersion} is
* equal to the argument {@code SemanticVersion}; a value less than
* {@code 0} if this {@code SemanticVersion} is less
* than the argument {@code SemanticVersion}; and a value greater
* than {@code 0} if this {@code SemanticVersion} is
* greater than the argument {@code SemanticVersion}.
*/
public int compareTo(
SemanticVersion o,
Comparator> prefixComparator
) {
int cmp = prefixComparator.compare(getPrefix(), o.getPrefix());
if (cmp != 0) {
return cmp;
}
cmp = Integer.compare(getMajor(), o.getMajor());
if (cmp != 0) {
return cmp;
}
cmp = Integer.compare(getMinor(), o.getMinor());
if (cmp != 0) {
return cmp;
}
cmp = Integer.compare(getPatch(), o.getPatch());
if (cmp != 0) {
return cmp;
}
if (!getPreRelease().isPresent() && !o.getPreRelease().isPresent()) {
return 0;
}
if (!getPreRelease().isPresent()) {
return 1;
}
if (!o.getPreRelease().isPresent()) {
return -1;
}
return comparePreRelease(getPreRelease().get(), o.getPreRelease().get());
}
private static int comparePreRelease(String x, String y) {
String[] xIdentifiers = x.split("\\.");
String[] yIdentifiers = y.split("\\.");
int cmp = 0;
int xPos = 0;
int yPos = 0;
while (xPos < xIdentifiers.length && yPos < yIdentifiers.length && cmp == 0) {
Optional xInt = parsePositiveInteger(xIdentifiers[xPos]);
Optional yInt = parsePositiveInteger(yIdentifiers[yPos]);
if (xInt.isPresent() && yInt.isPresent()) {
cmp = Integer.compare(xInt.get(), yInt.get());
continue;
}
if (xInt.isPresent()) {
cmp = -1;
continue;
}
if (yInt.isPresent()) {
cmp = 1;
continue;
}
cmp = xIdentifiers[xPos].compareTo(yIdentifiers[yPos]);
xPos++;
yPos++;
}
if (cmp != 0) {
return cmp;
}
int xRemaining = xIdentifiers.length - 1 - xPos;
int yRemaining = yIdentifiers.length - 1 - yPos;
if (xRemaining == yRemaining) {
return 0;
}
return (xRemaining < yRemaining) ? -1 : 1;
}
private static Optional parsePositiveInteger(String value) {
try {
int i = Integer.parseInt(value);
if (i < 0) {
return Optional.empty();
}
return Optional.of(i);
} catch (NumberFormatException e) {
return Optional.empty();
}
}
/**
* Builder for {@link SemanticVersion}.
*/
public static final class Builder implements SmithyBuilder {
private String prefix;
private int major;
private int minor;
private int patch;
private String preRelease;
private String build;
private Builder() {
}
public Builder prefix(String prefix) {
this.prefix = prefix;
return this;
}
public Builder major(int major) {
this.major = major;
return this;
}
public Builder minor(int minor) {
this.minor = minor;
return this;
}
public Builder patch(int patch) {
this.patch = patch;
return this;
}
public Builder preRelease(String preRelease) {
this.preRelease = preRelease;
return this;
}
public Builder build(String build) {
this.build = build;
return this;
}
@Override
public SemanticVersion build() {
return new SemanticVersion(this);
}
}
}
ServiceGenerator.java 0000664 0000000 0000000 00000051725 15102203672 0035611 0 ustar 00root root 0000000 0000000 smithy-go-1.23.2/codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.smithy.go.codegen;
import static software.amazon.smithy.go.codegen.GoWriter.autoDocTemplate;
import static software.amazon.smithy.go.codegen.GoWriter.emptyGoTemplate;
import static software.amazon.smithy.go.codegen.GoWriter.goDocTemplate;
import static software.amazon.smithy.go.codegen.GoWriter.goTemplate;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.auth.AuthSchemeResolverGenerator;
import software.amazon.smithy.go.codegen.auth.GetIdentityMiddlewareGenerator;
import software.amazon.smithy.go.codegen.auth.ResolveAuthSchemeMiddlewareGenerator;
import software.amazon.smithy.go.codegen.auth.SignRequestMiddlewareGenerator;
import software.amazon.smithy.go.codegen.endpoints.EndpointMiddlewareGenerator;
import software.amazon.smithy.go.codegen.integration.AuthSchemeDefinition;
import software.amazon.smithy.go.codegen.integration.ClientMember;
import software.amazon.smithy.go.codegen.integration.ClientMemberResolver;
import software.amazon.smithy.go.codegen.integration.ConfigFieldResolver;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.OperationMetricsStruct;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.ServiceIndex;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.utils.MapUtils;
/**
* Generates a service client, its constructors, and core supporting logic.
*/
final class ServiceGenerator implements Runnable {
public static final String CONFIG_NAME = "Options";
private final GoSettings settings;
private final Model model;
private final SymbolProvider symbolProvider;
private final GoWriter writer;
private final ServiceShape service;
private final List integrations;
private final List runtimePlugins;
private final ApplicationProtocol applicationProtocol;
private final Map