private FieldSymbol BuildField(FieldDeclarationNode fieldNode, TypeSymbol typeSymbol) { TypeSymbol fieldType = typeSymbol.SymbolSet.ResolveType(fieldNode.Type, _symbolTable, typeSymbol); Debug.Assert(fieldType != null); if (fieldType != null) { FieldSymbol symbol = new FieldSymbol(fieldNode.Name, typeSymbol, fieldType); BuildMemberDetails(symbol, typeSymbol, fieldNode, fieldNode.Attributes); if (fieldNode.Initializers.Count != 0) { VariableInitializerNode initializer = (VariableInitializerNode)fieldNode.Initializers[0]; if ((initializer.Value != null) && (initializer.Value.NodeType != ParseNodeType.Literal)) { symbol.SetImplementationState(/* hasInitializer */ true); } } if (fieldNode.NodeType == ParseNodeType.ConstFieldDeclaration) { Debug.Assert(fieldNode.Initializers.Count == 1); VariableInitializerNode initializer = (VariableInitializerNode)fieldNode.Initializers[0]; if ((initializer.Value != null) && (initializer.Value.NodeType == ParseNodeType.Literal)) { symbol.SetConstant(); symbol.Value = ((LiteralToken)initializer.Value.Token).LiteralValue; } // TODO: Handle other constant cases that can be evaluated at compile // time (eg. combining enum flags) } return symbol; } return null; }
public ExpressionBuilder(ILocalSymbolTable symbolTable, FieldSymbol fieldContext, IErrorHandler errorHandler, CompilerOptions options) { _symbolTable = symbolTable; _symbolContext = fieldContext; _classContext = ((ClassSymbol)fieldContext.Parent).PrimaryPartialClass; _symbolSet = fieldContext.SymbolSet; _errorHandler = errorHandler; _options = options; }
private static void GenerateFieldComment(ScriptTextWriter writer, FieldSymbol fieldSymbol) { writer.Write("/// <field name=\"{0}\"", fieldSymbol.GeneratedName); GenerateTypeAttributes(writer, fieldSymbol.AssociatedType); if ((fieldSymbol.Visibility & MemberVisibility.Static) != 0) { writer.Write(" static=\"true\""); } writer.WriteLine(">"); GenerateFormattedComment(writer, fieldSymbol.Documentation); writer.WriteLine("/// </field>"); }
private static void GenerateField(ScriptGenerator generator, string typeName, FieldSymbol fieldSymbol) { ScriptTextWriter writer = generator.Writer; bool instanceMember = true; if ((fieldSymbol.Visibility & MemberVisibility.Static) != 0) { instanceMember = false; writer.Write(typeName); writer.Write("."); } writer.Write(fieldSymbol.GeneratedName); if (instanceMember) { writer.WriteTrimmed(": "); } else { writer.WriteTrimmed(" = "); } CodeGenerator.GenerateScript(generator, fieldSymbol); if (instanceMember == false) { writer.Write(";"); writer.WriteNewLine(); } }
private void BuildCode(FieldSymbol fieldSymbol) { ImplementationBuilder implBuilder = new ImplementationBuilder(_options, _errorHandler); fieldSymbol.AddImplementation(implBuilder.BuildField(fieldSymbol)); _implementations.Add(fieldSymbol.Implementation); }
public static void GenerateScript(ScriptGenerator generator, FieldSymbol symbol) { GenerateImplementationScript(generator, symbol, symbol.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; }
public FieldExpression(Expression objectReference, FieldSymbol field) : this(ExpressionType.Field, objectReference, field) { }
protected FieldExpression(ExpressionType type, Expression objectReference, FieldSymbol field) : base(type, field.AssociatedType, SymbolFilter.Public | SymbolFilter.InstanceMembers) { _field = field; _objectReference = objectReference; }
public FieldExpression(Expression objectReference, FieldSymbol field) : this(ExpressionType.Field, objectReference, field) { }
private void DumpField(FieldSymbol fieldSymbol) { }
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 DumpField(FieldSymbol fieldSymbol) { }
protected FieldExpression(ExpressionType type, Expression objectReference, FieldSymbol field) : base(type, field.AssociatedType, SymbolFilter.Public | SymbolFilter.InstanceMembers) { _field = field; _objectReference = objectReference; }
private void BuildMembers(TypeSymbol typeSymbol) { if (typeSymbol.Type == SymbolType.Delegate) { DelegateTypeNode delegateNode = (DelegateTypeNode)typeSymbol.ParseContext; TypeSymbol returnType = typeSymbol.SymbolSet.ResolveType(delegateNode.ReturnType, _symbolTable, typeSymbol); Debug.Assert(returnType != null); if (returnType != null) { MethodSymbol invokeMethod = new MethodSymbol("Invoke", typeSymbol, returnType, MemberVisibility.Public); invokeMethod.SetTransformedName(String.Empty); // Mark the method as abstract, as there is no actual implementation of the method // to be generated invokeMethod.SetImplementationState(SymbolImplementationFlags.Abstract); typeSymbol.AddMember(invokeMethod); } return; } CustomTypeNode typeNode = (CustomTypeNode)typeSymbol.ParseContext; foreach (MemberNode member in typeNode.Members) { MemberSymbol memberSymbol = null; switch (member.NodeType) { case ParseNodeType.FieldDeclaration: case ParseNodeType.ConstFieldDeclaration: memberSymbol = BuildField((FieldDeclarationNode)member, typeSymbol); break; case ParseNodeType.PropertyDeclaration: memberSymbol = BuildPropertyAsField((PropertyDeclarationNode)member, typeSymbol); if (memberSymbol == null) { memberSymbol = BuildProperty((PropertyDeclarationNode)member, typeSymbol); } break; case ParseNodeType.IndexerDeclaration: memberSymbol = BuildIndexer((IndexerDeclarationNode)member, typeSymbol); break; case ParseNodeType.ConstructorDeclaration: case ParseNodeType.MethodDeclaration: if ((member.Modifiers & Modifiers.Extern) != 0) { // Extern methods are there for defining overload signatures, so // we just skip them as far as metadata goes. The validator has // taken care of the requirements/constraints around use of extern methods. continue; } memberSymbol = BuildMethod((MethodDeclarationNode)member, typeSymbol); break; case ParseNodeType.EventDeclaration: memberSymbol = BuildEvent((EventDeclarationNode)member, typeSymbol); break; case ParseNodeType.EnumerationFieldDeclaration: memberSymbol = BuildEnumField((EnumerationFieldNode)member, typeSymbol); break; } if (memberSymbol != null) { memberSymbol.SetParseContext(member); if ((typeSymbol.IsApplicationType == false) && ((memberSymbol.Type == SymbolType.Constructor) || (typeSymbol.GetMember(memberSymbol.Name) != null))) { // If the type is an imported type, then it is allowed to contain // overloads, and we're simply going to ignore its existence, as long // as one overload has been added to the member table. continue; } typeSymbol.AddMember(memberSymbol); if ((typeSymbol.Type == SymbolType.Class) && (memberSymbol.Type == SymbolType.Event)) { EventSymbol eventSymbol = (EventSymbol)memberSymbol; if (eventSymbol.DefaultImplementation) { // Add a private field that will serve as the backing member // later on in the conversion (eg. in non-event expressions) MemberVisibility visibility = MemberVisibility.PrivateInstance; if ((eventSymbol.Visibility & MemberVisibility.Static) != 0) { visibility |= MemberVisibility.Static; } FieldSymbol fieldSymbol = new FieldSymbol("__" + Utility.CreateCamelCaseName(eventSymbol.Name), typeSymbol, eventSymbol.AssociatedType); fieldSymbol.SetVisibility(visibility); fieldSymbol.SetParseContext(((EventDeclarationNode)eventSymbol.ParseContext).Field); typeSymbol.AddMember(fieldSymbol); } } } } }
private FieldSymbol BuildPropertyAsField(PropertyDeclarationNode propertyNode, TypeSymbol typeSymbol) { AttributeNode intrinsicPropertyAttribute = AttributeNode.FindAttribute(propertyNode.Attributes, "IntrinsicProperty"); if (intrinsicPropertyAttribute == null) { return null; } TypeSymbol fieldType = typeSymbol.SymbolSet.ResolveType(propertyNode.Type, _symbolTable, typeSymbol); Debug.Assert(fieldType != null); if (fieldType != null) { FieldSymbol symbol = new FieldSymbol(propertyNode.Name, typeSymbol, fieldType); BuildMemberDetails(symbol, typeSymbol, propertyNode, propertyNode.Attributes); string scriptAlias = GetAttributeValue(propertyNode.Attributes, "ScriptAlias"); if (scriptAlias != null) { symbol.SetAlias(scriptAlias); } return symbol; } return null; }
private void ImportFields(TypeSymbol typeSymbol) { TypeDefinition type = (TypeDefinition)typeSymbol.MetadataReference; foreach (FieldDefinition field in type.Fields) { if (field.IsSpecialName) { continue; } if (field.IsPrivate || field.IsAssembly || field.IsFamilyAndAssembly) { continue; } string fieldName = field.Name; TypeSymbol fieldType = ResolveType(field.FieldType); if (fieldType == null) { continue; } MemberVisibility visibility = MemberVisibility.PrivateInstance; if (field.IsStatic) { visibility |= MemberVisibility.Static; } if (field.IsPublic) { visibility |= MemberVisibility.Public; } else if (field.IsFamily || field.IsFamilyOrAssembly) { visibility |= MemberVisibility.Protected; } FieldSymbol fieldSymbol = new FieldSymbol(fieldName, typeSymbol, fieldType); fieldSymbol.SetVisibility(visibility); ImportMemberDetails(fieldSymbol, null, field); typeSymbol.AddMember(fieldSymbol); } }
public SymbolImplementation BuildField(FieldSymbol fieldSymbol) { _rootScope = new SymbolScope((ISymbolTable)fieldSymbol.Parent); _currentScope = _rootScope; Expression initializerExpression; FieldDeclarationNode fieldDeclarationNode = (FieldDeclarationNode)fieldSymbol.ParseContext; Debug.Assert(fieldDeclarationNode != null); VariableInitializerNode initializerNode = (VariableInitializerNode)fieldDeclarationNode.Initializers[0]; if (initializerNode.Value != null) { ExpressionBuilder expressionBuilder = new ExpressionBuilder(this, fieldSymbol, _errorHandler, _options); initializerExpression = expressionBuilder.BuildExpression(initializerNode.Value); if (initializerExpression is MemberExpression) { initializerExpression = expressionBuilder.TransformMemberExpression((MemberExpression)initializerExpression); } } else { object defaultValue = null; TypeSymbol fieldType = fieldSymbol.AssociatedType; SymbolSet symbolSet = fieldSymbol.SymbolSet; if (fieldType.Type == SymbolType.Enumeration) { // The default for named values is null, so this only applies to // regular enum types EnumerationSymbol enumType = (EnumerationSymbol)fieldType; if (enumType.UseNamedValues == false) { defaultValue = 0; } } else if ((fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Integer)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedInteger)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Long)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedLong)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Short)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedShort)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Byte)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.SignedByte)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Double)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Single)) || (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Decimal))) { defaultValue = 0; } else if (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Boolean)) { defaultValue = false; } initializerExpression = new LiteralExpression(symbolSet.ResolveIntrinsicType(IntrinsicType.Object), defaultValue); } List<Statement> statements = new List<Statement>(); statements.Add(new ExpressionStatement(initializerExpression, /* isFragment */ true)); return new SymbolImplementation(statements, 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); } } }