public static void GenerateScript(ScriptGenerator generator, PropertySymbol symbol, bool getter) {
SymbolImplementation accessorImpl;
if (getter) {
accessorImpl = symbol.GetterImplementation;
}
else {
accessorImpl = symbol.SetterImplementation;
}
GenerateImplementationScript(generator, symbol, accessorImpl);
}
public SymbolImplementation BuildPropertySetter(PropertySymbol propertySymbol)
{
AccessorNode setterNode = ((PropertyDeclarationNode)propertySymbol.ParseContext).SetAccessor;
BlockStatementNode accessorBody = setterNode.Implementation;
return BuildImplementation((ISymbolTable)propertySymbol.Parent,
propertySymbol, accessorBody, /* addAllParameters */ true);
}
private PropertySymbol BuildProperty(PropertyDeclarationNode propertyNode, TypeSymbol typeSymbol) {
TypeSymbol propertyType = typeSymbol.SymbolSet.ResolveType(propertyNode.Type, _symbolTable, typeSymbol);
Debug.Assert(propertyType != null);
if (propertyType != null) {
PropertySymbol property = new PropertySymbol(propertyNode.Name, typeSymbol, propertyType);
BuildMemberDetails(property, typeSymbol, propertyNode, propertyNode.Attributes);
SymbolImplementationFlags implFlags = SymbolImplementationFlags.Regular;
if (propertyNode.SetAccessor == null) {
implFlags |= SymbolImplementationFlags.ReadOnly;
}
if ((propertyNode.Modifiers & Modifiers.Abstract) != 0) {
implFlags |= SymbolImplementationFlags.Abstract;
}
else if ((propertyNode.Modifiers & Modifiers.Override) != 0) {
implFlags |= SymbolImplementationFlags.Override;
}
property.SetImplementationState(implFlags);
property.AddParameter(new ParameterSymbol("value", property, propertyType, ParameterMode.In));
return property;
}
return null;
}
private static void GenerateProperty(ScriptGenerator generator, string typeName, PropertySymbol propertySymbol) {
if (propertySymbol.IsAbstract) {
return;
}
ScriptTextWriter writer = generator.Writer;
bool instanceMember = true;
if ((propertySymbol.Visibility & MemberVisibility.Static) != 0) {
instanceMember = false;
writer.Write(typeName);
writer.Write(".");
}
writer.Write("get_");
writer.Write(propertySymbol.GeneratedName);
if (instanceMember) {
writer.WriteTrimmed(": ");
}
else {
writer.WriteTrimmed(" = ");
}
writer.Write("function");
if (generator.Options.DebugFlavor) {
writer.Write(" ");
writer.Write(typeName.Replace(".", "_"));
writer.Write("$get_");
writer.Write(propertySymbol.GeneratedName);
}
writer.Write("()");
writer.WriteTrimmed(" {");
writer.WriteNewLine();
writer.Indent++;
if (generator.Options.EnableDocComments) {
DocCommentGenerator.GenerateComment(generator, propertySymbol);
}
CodeGenerator.GenerateScript(generator, propertySymbol, /* getter */ true);
writer.Indent--;
writer.Write("}");
if (instanceMember == false) {
writer.WriteSignificantNewLine();
}
if (propertySymbol.IsReadOnly == false) {
ParameterSymbol valueParameter = propertySymbol.Parameters[0];
if (generator.Options.Minimize) {
bool obfuscateParams = !propertySymbol.IsPublic;
if (obfuscateParams) {
valueParameter.SetTransformedName("$p0");
}
}
if (instanceMember) {
writer.Write(",");
writer.WriteNewLine();
}
else {
writer.Write(typeName);
writer.Write(".");
}
writer.Write("set_");
writer.Write(propertySymbol.GeneratedName);
if (instanceMember) {
writer.WriteTrimmed(": ");
}
else {
writer.WriteTrimmed(" = ");
}
writer.Write("function");
if (generator.Options.DebugFlavor) {
writer.Write(" ");
writer.Write(typeName.Replace(".", "_"));
writer.Write("$set_");
writer.Write(propertySymbol.GeneratedName);
}
writer.Write("(");
writer.Write(valueParameter.GeneratedName);
writer.Write(")");
writer.WriteTrimmed(" {");
writer.WriteNewLine();
writer.Indent++;
if (generator.Options.EnableDocComments) {
DocCommentGenerator.GenerateComment(generator, propertySymbol);
}
CodeGenerator.GenerateScript(generator, propertySymbol, /* getter */ false);
writer.Write("return ");
writer.Write(valueParameter.GeneratedName);
writer.Write(";");
writer.WriteNewLine();
writer.Indent--;
writer.Write("}");
if (instanceMember == false) {
writer.WriteSignificantNewLine();
}
}
}
private static void GenerateIndexer(ScriptGenerator generator, string typeName, PropertySymbol indexerSymbol) {
if (indexerSymbol.IsAbstract) {
return;
}
ScriptTextWriter writer = generator.Writer;
bool instanceMember = true;
if ((indexerSymbol.Visibility & MemberVisibility.Static) != 0) {
instanceMember = false;
writer.Write(typeName);
writer.Write(".");
}
bool obfuscateParams = !indexerSymbol.IsPublic;
if (obfuscateParams && generator.Options.Minimize) {
for (int i = 0; i < indexerSymbol.Parameters.Count; i++) {
ParameterSymbol parameterSymbol = indexerSymbol.Parameters[i];
parameterSymbol.SetTransformedName("$p" + i);
}
}
writer.Write("get_");
writer.Write(indexerSymbol.GeneratedName);
if (instanceMember) {
writer.WriteTrimmed(": ");
}
else {
writer.WriteTrimmed(" = ");
}
writer.Write("function");
if (generator.Options.DebugFlavor) {
writer.Write(" ");
writer.Write(typeName.Replace(".", "_"));
writer.Write("$get_");
writer.Write(indexerSymbol.GeneratedName);
}
writer.Write("(");
for (int i = 0; i < indexerSymbol.Parameters.Count - 1; i++) {
ParameterSymbol parameterSymbol = indexerSymbol.Parameters[i];
if (i > 0) {
writer.WriteTrimmed(", ");
}
writer.Write(parameterSymbol.GeneratedName);
}
writer.Write(")");
writer.WriteTrimmed(" {");
writer.WriteNewLine();
writer.Indent++;
if (generator.Options.EnableDocComments) {
DocCommentGenerator.GenerateComment(generator, indexerSymbol);
}
CodeGenerator.GenerateScript(generator, (IndexerSymbol)indexerSymbol, /* getter */ true);
writer.Indent--;
writer.Write("}");
if (instanceMember == false) {
writer.WriteSignificantNewLine();
}
if (indexerSymbol.IsReadOnly == false) {
if (instanceMember) {
writer.Write(",");
writer.WriteNewLine();
}
else {
writer.Write(typeName);
writer.Write(".");
}
writer.Write("set_");
writer.Write(indexerSymbol.GeneratedName);
if (instanceMember) {
writer.WriteTrimmed(": ");
}
else {
writer.WriteTrimmed(" = ");
}
writer.Write("function");
if (generator.Options.DebugFlavor) {
writer.Write(" ");
writer.Write(typeName.Replace(".", "_"));
writer.Write("$set_");
writer.Write(indexerSymbol.GeneratedName);
}
writer.Write("(");
for (int i = 0; i < indexerSymbol.Parameters.Count; i++) {
ParameterSymbol parameterSymbol = indexerSymbol.Parameters[i];
if (i > 0) {
writer.WriteTrimmed(", ");
}
writer.Write(parameterSymbol.GeneratedName);
}
writer.Write(")");
writer.WriteTrimmed(" {");
writer.WriteNewLine();
writer.Indent++;
if (generator.Options.EnableDocComments) {
DocCommentGenerator.GenerateComment(generator, indexerSymbol);
}
CodeGenerator.GenerateScript(generator, (IndexerSymbol)indexerSymbol, /* getter */ false);
writer.Write("return ");
writer.Write(indexerSymbol.Parameters[indexerSymbol.Parameters.Count - 1].GeneratedName);
writer.Write(";");
writer.WriteNewLine();
writer.Indent--;
writer.Write("}");
if (instanceMember == false) {
writer.WriteSignificantNewLine();
}
}
}
public PropertyExpression(Expression objectReference, PropertySymbol property, bool getter)
: base((getter ? ExpressionType.PropertyGet : ExpressionType.PropertySet), property.AssociatedType, SymbolFilter.Public | SymbolFilter.InstanceMembers)
{
_property = property;
_objectReference = objectReference;
}
private static void GeneratePropertyComment(ScriptTextWriter writer, PropertySymbol propertySymbol) {
GenerateSummaryComment(writer, propertySymbol);
writer.Write("/// <value");
GenerateTypeAttributes(writer, propertySymbol.AssociatedType);
writer.WriteLine("></value>");
}
private void BuildCode(PropertySymbol propertySymbol)
{
if (propertySymbol.IsAbstract) {
return;
}
ImplementationBuilder implBuilder = new ImplementationBuilder(_options, _errorHandler);
propertySymbol.AddImplementation(implBuilder.BuildPropertyGetter(propertySymbol), /* getter */ true);
_implementations.Add(propertySymbol.GetterImplementation);
if (propertySymbol.IsReadOnly == false) {
propertySymbol.AddImplementation(implBuilder.BuildPropertySetter(propertySymbol), /* getter */ false);
_implementations.Add(propertySymbol.SetterImplementation);
}
if (propertySymbol.AnonymousMethods != null) {
foreach (AnonymousMethodSymbol anonymousMethod in propertySymbol.AnonymousMethods) {
Debug.Assert(anonymousMethod.Implementation != null);
_implementations.Add(anonymousMethod.Implementation);
}
}
}
private MemberSymbol CreateGenericMember(MemberSymbol templateMember, IList<TypeSymbol> typeArguments)
{
TypeSymbol parentType = (TypeSymbol)templateMember.Parent;
TypeSymbol instanceAssociatedType;
if (templateMember.AssociatedType.Type == SymbolType.GenericParameter) {
GenericParameterSymbol genericParameter = (GenericParameterSymbol)templateMember.AssociatedType;
instanceAssociatedType = typeArguments[genericParameter.Index];
}
else {
instanceAssociatedType = typeArguments[0];
}
if (templateMember.Type == SymbolType.Indexer) {
IndexerSymbol templateIndexer = (IndexerSymbol)templateMember;
IndexerSymbol instanceIndexer = new IndexerSymbol(parentType, instanceAssociatedType);
if (templateIndexer.UseScriptIndexer) {
instanceIndexer.SetScriptIndexer();
}
instanceIndexer.SetVisibility(templateIndexer.Visibility);
return instanceIndexer;
}
else if (templateMember.Type == SymbolType.Property) {
PropertySymbol templateProperty = (PropertySymbol)templateMember;
PropertySymbol instanceProperty = new PropertySymbol(templateProperty.Name, parentType, instanceAssociatedType);
if (templateProperty.IsTransformed) {
instanceProperty.SetTransformedName(templateProperty.GeneratedName);
}
instanceProperty.SetNameCasing(templateProperty.IsCasePreserved);
instanceProperty.SetVisibility(templateProperty.Visibility);
return instanceProperty;
}
else if (templateMember.Type == SymbolType.Field) {
FieldSymbol templateField = (FieldSymbol)templateMember;
FieldSymbol instanceField = new FieldSymbol(templateField.Name, parentType, instanceAssociatedType);
if (templateField.IsTransformed) {
instanceField.SetTransformedName(templateField.GeneratedName);
}
instanceField.SetNameCasing(templateField.IsCasePreserved);
instanceField.SetVisibility(templateField.Visibility);
return instanceField;
}
else if (templateMember.Type == SymbolType.Method) {
MethodSymbol templateMethod = (MethodSymbol)templateMember;
MethodSymbol instanceMethod = new MethodSymbol(templateMethod.Name, parentType, instanceAssociatedType);
if (templateMethod.IsAliased) {
instanceMethod.SetAlias(templateMethod.Alias);
}
else if (templateMethod.IsTransformed) {
instanceMethod.SetTransformedName(templateMethod.GeneratedName);
}
if (templateMethod.SkipGeneration) {
instanceMethod.SetSkipGeneration();
}
if (templateMethod.InterfaceMember != null) {
instanceMethod.SetInterfaceMember(templateMethod.InterfaceMember);
}
instanceMethod.SetNameCasing(templateMethod.IsCasePreserved);
instanceMethod.SetVisibility(templateMethod.Visibility);
return instanceMethod;
}
Debug.Fail("Unexpected generic member '" + templateMember.Name + " on type '" + ((TypeSymbol)templateMember.Parent).FullName + "'.");
return null;
}
private void ImportProperties(TypeSymbol typeSymbol)
{
TypeDefinition type = (TypeDefinition)typeSymbol.MetadataReference;
foreach (PropertyDefinition property in type.Properties) {
if (property.IsSpecialName) {
continue;
}
if (property.GetMethod == null) {
continue;
}
if (property.GetMethod.IsPrivate || property.GetMethod.IsAssembly || property.GetMethod.IsFamilyAndAssembly) {
continue;
}
string propertyName = property.Name;
bool preserveCase = MetadataHelpers.ShouldPreserveCase(property);
bool intrinsicProperty = MetadataHelpers.ShouldTreatAsIntrinsicProperty(property);
TypeSymbol propertyType = ResolveType(property.PropertyType);
if (propertyType == null) {
continue;
}
PropertySymbol propertySymbol = null;
if (property.Parameters.Count != 0) {
IndexerSymbol indexerSymbol = new IndexerSymbol(typeSymbol, propertyType);
ImportMemberDetails(indexerSymbol, property.GetMethod, property);
if (intrinsicProperty) {
indexerSymbol.SetIntrinsic();
}
propertySymbol = indexerSymbol;
propertySymbol.SetNameCasing(preserveCase);
}
else {
if (intrinsicProperty) {
// Properties marked with this attribute are to be thought of as
// fields. If they are read-only, the C# compiler will enforce that,
// so we don't have to worry about making them read-write via a field
// instead of a property
FieldSymbol fieldSymbol = new FieldSymbol(propertyName, typeSymbol, propertyType);
ImportMemberDetails(fieldSymbol, property.GetMethod, property);
string alias = MetadataHelpers.GetScriptAlias(property);
if (String.IsNullOrEmpty(alias) == false) {
fieldSymbol.SetAlias(alias);
}
typeSymbol.AddMember(fieldSymbol);
}
else {
propertySymbol = new PropertySymbol(propertyName, typeSymbol, propertyType);
ImportMemberDetails(propertySymbol, property.GetMethod, property);
}
}
if (propertySymbol != null) {
SymbolImplementationFlags implFlags = SymbolImplementationFlags.Regular;
if (property.SetMethod == null) {
implFlags |= SymbolImplementationFlags.ReadOnly;
}
if (property.GetMethod.IsAbstract) {
implFlags |= SymbolImplementationFlags.Abstract;
}
propertySymbol.SetImplementationState(implFlags);
typeSymbol.AddMember(propertySymbol);
}
}
}
private MemberSymbol CreateGenericMember(MemberSymbol templateMember, IList <TypeSymbol> typeArguments)
{
TypeSymbol parentType = (TypeSymbol)templateMember.Parent;
TypeSymbol instanceAssociatedType;
if (templateMember.AssociatedType.Type == SymbolType.GenericParameter)
{
GenericParameterSymbol genericParameter = (GenericParameterSymbol)templateMember.AssociatedType;
instanceAssociatedType = typeArguments[genericParameter.Index];
}
else
{
instanceAssociatedType = typeArguments[0];
}
if (templateMember.Type == SymbolType.Indexer)
{
IndexerSymbol templateIndexer = (IndexerSymbol)templateMember;
IndexerSymbol instanceIndexer = new IndexerSymbol(parentType, instanceAssociatedType);
if (templateIndexer.IsIntrinsic)
{
instanceIndexer.SetIntrinsic();
}
instanceIndexer.SetVisibility(templateIndexer.Visibility);
return(instanceIndexer);
}
else if (templateMember.Type == SymbolType.Property)
{
PropertySymbol templateProperty = (PropertySymbol)templateMember;
PropertySymbol instanceProperty = new PropertySymbol(templateProperty.Name, parentType, instanceAssociatedType);
if (templateProperty.IsTransformed)
{
instanceProperty.SetTransformedName(templateProperty.GeneratedName);
}
instanceProperty.SetNameCasing(templateProperty.IsCasePreserved);
instanceProperty.SetVisibility(templateProperty.Visibility);
return(instanceProperty);
}
else if (templateMember.Type == SymbolType.Field)
{
FieldSymbol templateField = (FieldSymbol)templateMember;
FieldSymbol instanceField = new FieldSymbol(templateField.Name, parentType, instanceAssociatedType);
if (templateField.IsTransformed)
{
instanceField.SetTransformedName(templateField.GeneratedName);
}
instanceField.SetNameCasing(templateField.IsCasePreserved);
instanceField.SetVisibility(templateField.Visibility);
return(instanceField);
}
else if (templateMember.Type == SymbolType.Method)
{
MethodSymbol templateMethod = (MethodSymbol)templateMember;
MethodSymbol instanceMethod = new MethodSymbol(templateMethod.Name, parentType, instanceAssociatedType);
if (templateMethod.IsTransformed)
{
instanceMethod.SetTransformedName(templateMethod.GeneratedName);
}
if (templateMethod.InterfaceMember != null)
{
instanceMethod.SetInterfaceMember(templateMethod.InterfaceMember);
}
instanceMethod.SetNameCasing(templateMethod.IsCasePreserved);
instanceMethod.SetVisibility(templateMethod.Visibility);
return(instanceMethod);
}
Debug.Fail("Unexpected generic member '" + templateMember.Name + " on type '" + ((TypeSymbol)templateMember.Parent).FullName + "'.");
return(null);
}
private void DumpProperty(PropertySymbol propertySymbol)
{
_writer.Write("ReadOnly: ");
_writer.WriteLine(propertySymbol.IsReadOnly);
_writer.Write("Abstract: ");
_writer.WriteLine(propertySymbol.IsAbstract);
}
