// generateVariables generates all the variables/fields under the given type or module into ES5.
func (gen *es5generator) generateVariables(typeOrModule typegraph.TGTypeOrModule, initMap varMap) {
members := typeOrModule.Members()
// Find all variables defined under the type or module.
for _, member := range members {
srgMember, hasSRGMember := gen.getSRGMember(member)
if !hasSRGMember || srgMember.MemberKind() != srg.VarMember {
continue
}
// If the variable has a base member (i.e. it shadows another variable),
// nothing more to do.
_, hasBaseMember := member.BaseMember()
if hasBaseMember {
continue
}
// We only need to generate variables that have initializers.
_, hasInitializer := srgMember.Initializer()
if !hasInitializer {
continue
}
initMap.Set(member, gen.generateVariable(member))
}
}
// generateImplementedMembers generates all the members under the given type or module into ES5.
func (gen *es5generator) generateImplementedMembers(typeOrModule typegraph.TGTypeOrModule) *ordered_map.OrderedMap {
memberMap := ordered_map.NewOrderedMap()
members := typeOrModule.Members()
for _, member := range members {
// Check for a base member. If one exists, generate the member has an aliased member.
_, hasBaseMember := member.BaseMember()
if hasBaseMember {
memberMap.Set(member, gen.generateImplementedAliasedMember(member))
continue
}
// Otherwise, generate the member if it has an implementation.
srgMember, hasSRGMember := gen.getSRGMember(member)
if !hasSRGMember || !srgMember.HasImplementation() {
continue
}
memberMap.Set(member, gen.generateImplementedMember(member))
}
return memberMap
}
// decorateMember decorates a single type member.
func (stc *srgTypeConstructor) decorateMember(member srg.SRGMember, parent typegraph.TGTypeOrModule, decorator *typegraph.MemberDecorator, reporter typegraph.IssueReporter, graph *typegraph.TypeGraph) {
// Add the generic's constraints.
for _, generic := range member.Generics() {
// Note: If the constraint is not valid, the resolve method will report the error and return Any, which is the correct type.
constraintType, _ := stc.resolvePossibleType(generic.Node(), generic.GetConstraint, graph, reporter)
decorator.DefineGenericConstraint(generic.Node(), constraintType)
}
// Build all member-specific information.
var memberType typegraph.TypeReference = graph.AnyTypeReference()
var memberKind typegraph.MemberSignatureKind = typegraph.CustomMemberSignature
var isReadOnly bool = true
var isStatic bool = false
var isPromising bool = true
var isImplicitlyCalled bool = false
var hasDefaultValue bool = false
var isField = false
switch member.MemberKind() {
case srg.VarMember:
// Variables have their declared type.
memberType, _ = stc.resolvePossibleType(member.Node(), member.DeclaredType, graph, reporter)
memberKind = typegraph.FieldMemberSignature
isReadOnly = false
isPromising = false
isField = true
_, hasDefaultValue = member.Node().TryGetNode(parser.NodePredicateTypeFieldDefaultValue)
case srg.PropertyMember:
// Properties have their declared type.
memberType, _ = stc.resolvePossibleType(member.Node(), member.DeclaredType, graph, reporter)
memberKind = typegraph.PropertyMemberSignature
isReadOnly = member.IsReadOnly()
isImplicitlyCalled = true
// Decorate the property *getter* with its return type.
getter, found := member.Getter()
if found {
decorator.CreateReturnable(getter.GraphNode, memberType)
}
case srg.ConstructorMember:
memberKind = typegraph.ConstructorMemberSignature
// Constructors are static.
isStatic = true
// Constructors have a type of a function that returns an instance of the parent type.
returnType := graph.NewInstanceTypeReference(parent.(typegraph.TGTypeDecl))
functionType := graph.NewTypeReference(graph.FunctionType(), returnType)
memberType, _ = stc.addSRGParameterTypes(member, functionType, graph, reporter)
// Decorate the constructor with its return type.
decorator.CreateReturnable(member.Node(), returnType)
// Constructors have custom signature types that return 'any' to allow them to match
// interfaces.
var signatureType = graph.FunctionTypeReference(graph.AnyTypeReference())
signatureType, _ = stc.addSRGParameterTypes(member, signatureType, graph, reporter)
decorator.SignatureType(signatureType)
case srg.OperatorMember:
memberKind = typegraph.OperatorMemberSignature
// Operators are read-only.
isReadOnly = true
// Operators have type function<DeclaredType>(parameters).
returnType, _ := stc.resolvePossibleType(member.Node(), member.DeclaredType, graph, reporter)
functionType := graph.NewTypeReference(graph.FunctionType(), returnType)
memberType, _ = stc.addSRGParameterTypes(member, functionType, graph, reporter)
// Make sure instance members under interfaces do not have bodies (and static members do).
if parent.IsType() {
parentType := parent.AsType()
if parentType.TypeKind() == typegraph.ImplicitInterfaceType {
opDef, found := graph.GetOperatorDefinition(member.Name())
// Note: If not found, the type graph will emit an error.
if found {
if member.HasImplementation() != opDef.IsStatic {
if opDef.IsStatic {
reporter.ReportError(member.GraphNode, "Static operator %v under %v %v must have an implementation", member.Name(), parentType.Title(), parentType.Name())
} else {
reporter.ReportError(member.GraphNode, "Instance operator %v under %v %v cannot have an implementation", member.Name(), parentType.Title(), parentType.Name())
}
}
}
}
}
// Note: Operators get decorated with a returnable by the construction system automatically.
case srg.FunctionMember:
memberKind = typegraph.FunctionMemberSignature
// Functions are read-only.
isReadOnly = true
// Functions have type function<ReturnType>(parameters).
returnType, _ := stc.resolvePossibleType(member.Node(), member.ReturnType, graph, reporter)
// Decorate the function with its return type.
decorator.CreateReturnable(member.Node(), returnType)
// If the function is an async function, make it non-promising and return a Awaitable instead.
if member.IsAsyncFunction() {
isPromising = false
returnType = graph.AwaitableTypeReference(returnType)
}
functionType := graph.NewTypeReference(graph.FunctionType(), returnType)
memberType, _ = stc.addSRGParameterTypes(member, functionType, graph, reporter)
}
// Decorate the member with whether it is exported.
decorator.Exported(member.IsExported())
// Decorate the member with whether it is an async function.
decorator.InvokesAsync(member.IsAsyncFunction())
// If the member is under a module, then it is static.
decorator.Static(isStatic || !parent.IsType())
// Decorate the member with whether it is promising.
decorator.Promising(isPromising)
// Decorate the member with whether it has a default value.
decorator.HasDefaultValue(hasDefaultValue)
// Decorate the member with whether it is a field.
decorator.Field(isField)
// Decorate the member with whether it is implicitly called.
decorator.ImplicitlyCalled(isImplicitlyCalled)
// Decorate the member with whether it is read-only.
decorator.ReadOnly(isReadOnly)
// Decorate the member with its type.
decorator.MemberType(memberType)
// Decorate the member with its kind.
decorator.MemberKind(memberKind)
// Decorate the member with its tags, if any.
for name, value := range member.Tags() {
decorator.WithTag(name, value)
}
// Finalize the member.
decorator.Decorate()
}