protected MethodExpression(ExpressionType type, Expression objectReference, MethodSymbol method, Collection<Expression> parameters) :
base(type, (method.AssociatedType.Type == SymbolType.GenericParameter ? objectReference.EvaluatedType : method.AssociatedType),
SymbolFilter.Public | SymbolFilter.InstanceMembers) {
_method = method;
_objectReference = objectReference;
_parameters = (parameters == null) ? new Collection<Expression>() : parameters;
}
private ParameterSymbol BuildParameter(ParameterNode parameterNode, MethodSymbol methodSymbol) {
ParameterMode parameterMode = ParameterMode.In;
if ((parameterNode.Flags == ParameterFlags.Out) ||
(parameterNode.Flags == ParameterFlags.Ref)) {
parameterMode = ParameterMode.InOut;
}
else if (parameterNode.Flags == ParameterFlags.Params) {
parameterMode = ParameterMode.List;
}
TypeSymbol parameterType = methodSymbol.SymbolSet.ResolveType(parameterNode.Type, _symbolTable, methodSymbol);
Debug.Assert(parameterType != null);
if (parameterType != null) {
return new ParameterSymbol(parameterNode.Name, methodSymbol, parameterType, parameterMode);
}
return null;
}
private MethodSymbol BuildMethod(MethodDeclarationNode methodNode, TypeSymbol typeSymbol) {
MethodSymbol method = null;
if (methodNode.NodeType == ParseNodeType.ConstructorDeclaration) {
method = new ConstructorSymbol(typeSymbol, (methodNode.Modifiers & Modifiers.Static) != 0);
}
else {
TypeSymbol returnType = typeSymbol.SymbolSet.ResolveType(methodNode.Type, _symbolTable, typeSymbol);
Debug.Assert(returnType != null);
if (returnType != null) {
method = new MethodSymbol(methodNode.Name, typeSymbol, returnType);
BuildMemberDetails(method, typeSymbol, methodNode, methodNode.Attributes);
ICollection<string> conditions = null;
foreach (AttributeNode attrNode in methodNode.Attributes) {
if (attrNode.TypeName.Equals("Conditional", StringComparison.Ordinal)) {
if (conditions == null) {
conditions = new List<string>();
}
Debug.Assert(attrNode.Arguments[0] is LiteralNode);
Debug.Assert(((LiteralNode)attrNode.Arguments[0]).Value is string);
conditions.Add((string)((LiteralNode)attrNode.Arguments[0]).Value);
}
}
if (conditions != null) {
method.SetConditions(conditions);
}
}
}
if (method != null) {
if ((methodNode.Modifiers & Modifiers.Abstract) != 0) {
method.SetImplementationState(SymbolImplementationFlags.Abstract);
}
else if ((methodNode.Modifiers & Modifiers.Override) != 0) {
method.SetImplementationState(SymbolImplementationFlags.Override);
}
if ((methodNode.Parameters != null) && (methodNode.Parameters.Count != 0)) {
foreach (ParameterNode parameterNode in methodNode.Parameters) {
ParameterSymbol paramSymbol = BuildParameter(parameterNode, method);
if (paramSymbol != null) {
paramSymbol.SetParseContext(parameterNode);
method.AddParameter(paramSymbol);
}
}
}
if ((method.Visibility & MemberVisibility.Static) != 0) {
string scriptAlias = GetAttributeValue(methodNode.Attributes, "ScriptAlias");
if (scriptAlias != null) {
method.SetAlias(scriptAlias);
}
}
}
return method;
}
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);
}
}
}
}
}
public MethodExpression(Expression objectReference, MethodSymbol method)
: this(ExpressionType.MethodInvoke, objectReference, method, null) {
}
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 static void GenerateMethod(ScriptGenerator generator, string typeName, MethodSymbol methodSymbol) {
if (methodSymbol.IsAbstract) {
return;
}
ScriptTextWriter writer = generator.Writer;
bool instanceMember = ((methodSymbol.Visibility & MemberVisibility.Static) == 0);
if (instanceMember == false) {
if (methodSymbol.IsGlobalMethod) {
string mixinRoot = null;
if (methodSymbol.Parent.Type == SymbolType.Class) {
mixinRoot = ((ClassSymbol)methodSymbol.Parent).MixinRoot;
}
if (String.IsNullOrEmpty(mixinRoot)) {
mixinRoot = "window";
}
writer.Write(mixinRoot);
}
else {
writer.Write(typeName);
}
writer.Write(".");
}
writer.Write(methodSymbol.GeneratedName);
if (instanceMember) {
writer.WriteTrimmed(": ");
}
else {
writer.WriteTrimmed(" = ");
}
writer.Write("function");
if (generator.Options.DebugFlavor) {
writer.Write(" ");
writer.Write(typeName.Replace(".", "_"));
writer.Write("$");
writer.Write(methodSymbol.GeneratedName);
}
writer.Write("(");
if (methodSymbol.Parameters != null) {
bool obfuscateParams = false;
if (generator.Options.Minimize) {
obfuscateParams = !methodSymbol.IsPublic;
}
int paramIndex = 0;
foreach (ParameterSymbol parameterSymbol in methodSymbol.Parameters) {
if (paramIndex > 0) {
writer.WriteTrimmed(", ");
}
if (obfuscateParams) {
parameterSymbol.SetTransformedName("$p" + paramIndex);
}
writer.Write(parameterSymbol.GeneratedName);
paramIndex++;
}
}
writer.WriteTrimmed(") ");
writer.Write("{");
writer.WriteNewLine();
writer.Indent++;
if (generator.Options.EnableDocComments) {
DocCommentGenerator.GenerateComment(generator, methodSymbol);
}
CodeGenerator.GenerateScript(generator, methodSymbol);
writer.Indent--;
writer.Write("}");
if (instanceMember == false) {
writer.WriteSignificantNewLine();
}
}
public static void GenerateScript(ScriptGenerator generator, MethodSymbol symbol) {
GenerateImplementationScript(generator, symbol, symbol.Implementation);
}
private void BuildCode(MethodSymbol methodSymbol)
{
if (methodSymbol.IsAbstract) {
return;
}
ImplementationBuilder implBuilder = new ImplementationBuilder(_options, _errorHandler);
methodSymbol.AddImplementation(implBuilder.BuildMethod(methodSymbol));
_implementations.Add(methodSymbol.Implementation);
if (methodSymbol.AnonymousMethods != null) {
foreach (AnonymousMethodSymbol anonymousMethod in methodSymbol.AnonymousMethods) {
Debug.Assert(anonymousMethod.Implementation != null);
_implementations.Add(anonymousMethod.Implementation);
}
}
}
private Expression ProcessDotExpressionNode(BinaryExpressionNode node) {
SymbolFilter filter = SymbolFilter.All;
MemberSymbol memberSymbol = null;
Expression objectExpression = ProcessDotExpressionNode(node, filter, out memberSymbol);
if (objectExpression == null) {
// We didn't successfully create an expression. The first pass attempted to
// process the right child as an instance member of the left child expression.
// We need to process the left child again as a type so we can process the
// right child as a static member this time around.
filter &= ~SymbolFilter.Members;
objectExpression = ProcessDotExpressionNode(node, filter, out memberSymbol);
}
Debug.Assert(objectExpression != null);
TypeSymbol dictionaryType = _symbolSet.ResolveIntrinsicType(IntrinsicType.Dictionary);
TypeSymbol genericDictionaryType = _symbolSet.ResolveIntrinsicType(IntrinsicType.GenericDictionary);
TypeSymbol nullableType = _symbolSet.ResolveIntrinsicType(IntrinsicType.Nullable);
if (memberSymbol.Type == SymbolType.Property) {
if ((memberSymbol.Parent == dictionaryType) ||
(memberSymbol.Parent == genericDictionaryType)) {
MethodSymbol methodSymbol = null;
if (String.CompareOrdinal(memberSymbol.Name, "Count") == 0) {
methodSymbol = (MethodSymbol)dictionaryType.GetMember("GetKeyCount");
Debug.Assert(methodSymbol != null);
}
else if (String.CompareOrdinal(memberSymbol.Name, "Keys") == 0) {
methodSymbol = (MethodSymbol)dictionaryType.GetMember("GetKeys");
Debug.Assert(methodSymbol != null);
}
if (methodSymbol != null) {
MethodExpression methodExpression =
new MethodExpression(new TypeExpression(dictionaryType, SymbolFilter.Public | SymbolFilter.StaticMembers),
methodSymbol);
methodExpression.AddParameterValue(objectExpression);
return methodExpression;
}
}
else if (memberSymbol.Parent == nullableType) {
if (String.CompareOrdinal(memberSymbol.Name, "Value") == 0) {
// Nullable<T>.Value becomes Nullable<T>
TypeSymbol underlyingType = objectExpression.EvaluatedType.GenericArguments.First();
objectExpression.Reevaluate(underlyingType);
return objectExpression;
}
else if (String.CompareOrdinal(memberSymbol.Name, "HasValue") == 0) {
// Nullable<T>.Value becomes Script.IsValue(Nullable<T>)
TypeSymbol scriptType = _symbolSet.ResolveIntrinsicType(IntrinsicType.Script);
MethodSymbol isValueMethod = (MethodSymbol)scriptType.GetMember("IsValue");
MethodExpression methodExpression
= new MethodExpression(new TypeExpression(scriptType, SymbolFilter.Public | SymbolFilter.StaticMembers),
isValueMethod);
methodExpression.AddParameterValue(objectExpression);
return methodExpression;
}
}
}
else if (memberSymbol.Type == SymbolType.Method) {
if (memberSymbol.Parent == nullableType) {
// Nullable<T>.GetValueOrDefault() becomes Nullable<T> || 0|false
TypeSymbol underlyingType = objectExpression.EvaluatedType.GenericArguments.First();
object defaultValue = 0;
if (underlyingType == _symbolSet.ResolveIntrinsicType(IntrinsicType.Boolean)) {
defaultValue = false;
}
else if (underlyingType == _symbolSet.ResolveIntrinsicType(IntrinsicType.String)) {
defaultValue = String.Empty;
}
LiteralExpression literalExpression = new LiteralExpression(underlyingType, defaultValue);
BinaryExpression logicalOrExpression = new BinaryExpression(Operator.LogicalOr, objectExpression, literalExpression);
logicalOrExpression.Reevaluate(underlyingType);
logicalOrExpression.AddParenthesisHint();
return logicalOrExpression;
}
}
string dependency = ((TypeSymbol)memberSymbol.Parent).DependencyName;
if (String.IsNullOrEmpty(dependency) == false) {
_options.AddExecutionDependency(dependency);
}
MemberExpression expression = new MemberExpression(objectExpression, memberSymbol);
if ((memberSymbol.Type == SymbolType.Method) &&
memberSymbol.AssociatedType.IsGeneric && (memberSymbol.AssociatedType.GenericArguments == null)) {
Debug.Assert(node.RightChild.NodeType == ParseNodeType.GenericName);
Debug.Assert(((GenericNameNode)node.RightChild).TypeArguments != null);
List<TypeSymbol> typeArgs = new List<TypeSymbol>();
foreach (ParseNode typeArgNode in ((GenericNameNode)node.RightChild).TypeArguments) {
typeArgs.Add(_symbolSet.ResolveType(typeArgNode, _symbolTable, _symbolContext));
}
TypeSymbol returnType = _symbolSet.CreateGenericTypeSymbol(memberSymbol.AssociatedType, typeArgs);
if (returnType != null) {
MethodSymbol genericMethod = (MethodSymbol)memberSymbol;
MethodSymbol instanceMethod = new MethodSymbol(genericMethod.Name, (TypeSymbol)genericMethod.Parent, returnType);
if (genericMethod.IsTransformed) {
instanceMethod.SetTransformedName(genericMethod.GeneratedName);
}
instanceMethod.SetNameCasing(genericMethod.IsCasePreserved);
expression = new MemberExpression(objectExpression, instanceMethod);
}
}
return expression;
}
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 ImportPseudoMembers(PseudoClassMembers memberSet, ClassSymbol classSymbol)
{
// Import pseudo members that go on the class but aren't defined in mscorlib.dll
// These are meant to be used by internal compiler-generated transformations etc.
// and aren't meant to be referenced directly in C# code.
if (memberSet == PseudoClassMembers.Script) {
TypeSymbol boolType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Boolean", null, SymbolFilter.Types);
Debug.Assert(boolType != null);
TypeSymbol intType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Int32", null, SymbolFilter.Types);
Debug.Assert(intType != null);
TypeSymbol floatType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Single", null, SymbolFilter.Types);
Debug.Assert(floatType != null);
TypeSymbol stringType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("String", null, SymbolFilter.Types);
Debug.Assert(stringType != null);
// Define the Escape, Unescape, encodeURI, decodeURI, encodeURIComponent, decodeURIComponent methods
MethodSymbol escapeMethod = new MethodSymbol("Escape", classSymbol, stringType, MemberVisibility.Public | MemberVisibility.Static);
classSymbol.AddMember(escapeMethod);
MethodSymbol unescapeMethod = new MethodSymbol("Unescape", classSymbol, stringType, MemberVisibility.Public | MemberVisibility.Static);
classSymbol.AddMember(unescapeMethod);
MethodSymbol encodeURIMethod = new MethodSymbol("EncodeUri", classSymbol, stringType, MemberVisibility.Public | MemberVisibility.Static);
encodeURIMethod.SetTransformedName("encodeURI");
classSymbol.AddMember(encodeURIMethod);
MethodSymbol decodeURIMethod = new MethodSymbol("DecodeUri", classSymbol, stringType, MemberVisibility.Public | MemberVisibility.Static);
decodeURIMethod.SetTransformedName("decodeURI");
classSymbol.AddMember(decodeURIMethod);
MethodSymbol encodeURIComponentMethod = new MethodSymbol("EncodeUriComponent", classSymbol, stringType, MemberVisibility.Public | MemberVisibility.Static);
encodeURIComponentMethod.SetTransformedName("encodeURIComponent");
classSymbol.AddMember(encodeURIComponentMethod);
MethodSymbol decodeURIComponentMethod = new MethodSymbol("DecodeUriComponent", classSymbol, stringType, MemberVisibility.Public | MemberVisibility.Static);
decodeURIComponentMethod.SetTransformedName("decodeURIComponent");
classSymbol.AddMember(decodeURIComponentMethod);
return;
}
if (memberSet == PseudoClassMembers.Arguments) {
TypeSymbol objectType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Object", null, SymbolFilter.Types);
Debug.Assert(objectType != null);
IndexerSymbol indexer = new IndexerSymbol(classSymbol, objectType, MemberVisibility.Public | MemberVisibility.Static);
indexer.SetIntrinsic();
classSymbol.AddMember(indexer);
return;
}
if (memberSet == PseudoClassMembers.Type) {
// Define the Type.GetInstanceType static method which provides the functionality of
// Object.GetType instance method. We don't extend Object.prototype in script to add
// GetType, since we want to keep Object's protoype clean of any extensions.
//
// We create this symbol here, so that later the ExpressionBuilder can transform
// calls to Object.GetType to this.
TypeSymbol objectType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Object", null, SymbolFilter.Types);
Debug.Assert(objectType != null);
TypeSymbol typeType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Type", null, SymbolFilter.Types);
Debug.Assert(objectType != null);
MethodSymbol getTypeMethod = new MethodSymbol("GetInstanceType", classSymbol, typeType, MemberVisibility.Public | MemberVisibility.Static);
getTypeMethod.AddParameter(new ParameterSymbol("instance", getTypeMethod, objectType, ParameterMode.In));
classSymbol.AddMember(getTypeMethod);
return;
}
if (memberSet == PseudoClassMembers.Dictionary) {
TypeSymbol intType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Int32", null, SymbolFilter.Types);
Debug.Assert(intType != null);
TypeSymbol boolType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Boolean", null, SymbolFilter.Types);
Debug.Assert(boolType != null);
TypeSymbol voidType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("Void", null, SymbolFilter.Types);
Debug.Assert(boolType != null);
TypeSymbol stringType = (TypeSymbol)((ISymbolTable)_symbols.SystemNamespace).FindSymbol("String", null, SymbolFilter.Types);
Debug.Assert(boolType != null);
// Define Dictionary.Keys
MethodSymbol getKeysMethod = new MethodSymbol("GetKeys", classSymbol, _symbols.CreateArrayTypeSymbol(stringType), MemberVisibility.Public | MemberVisibility.Static);
getKeysMethod.SetTransformedName("keys");
classSymbol.AddMember(getKeysMethod);
// Define Dictionary.GetCount
MethodSymbol countMethod = new MethodSymbol("GetKeyCount", classSymbol, intType, MemberVisibility.Public | MemberVisibility.Static);
classSymbol.AddMember(countMethod);
// Define Dictionary.ClearKeys
MethodSymbol clearMethod = new MethodSymbol("ClearKeys", classSymbol, voidType, MemberVisibility.Public | MemberVisibility.Static);
classSymbol.AddMember(clearMethod);
// Define Dictionary.DeleteKey
MethodSymbol deleteMethod = new MethodSymbol("DeleteKey", classSymbol, voidType, MemberVisibility.Public | MemberVisibility.Static);
classSymbol.AddMember(deleteMethod);
// Define Dictionary.KeyExists
MethodSymbol existsMethod = new MethodSymbol("KeyExists", classSymbol, boolType, MemberVisibility.Public | MemberVisibility.Static);
classSymbol.AddMember(existsMethod);
return;
}
if (memberSet == PseudoClassMembers.String) {
// In script, String.replace replaces only the first occurrence of a string
// whereas in C# all occurrences are replaced.
// Replace becomes replaceAll (a method we add) in generated script
// ReplaceFirst becomes replace in generated script.
// ReplaceRegex also becomes replace in generated script. (We added ReplaceRegex so
// it could be mapped to the native replace method, rather than out replaceAll
// extension)
MethodSymbol replaceFirstMethod = (MethodSymbol)classSymbol.GetMember("ReplaceFirst");
Debug.Assert(replaceFirstMethod != null);
replaceFirstMethod.SetTransformedName("replace");
MethodSymbol replaceMethod = (MethodSymbol)classSymbol.GetMember("Replace");
Debug.Assert(replaceMethod != null);
replaceMethod.SetTransformedName("replaceAll");
MethodSymbol replaceRegexMethod = (MethodSymbol)classSymbol.GetMember("ReplaceRegex");
Debug.Assert(replaceRegexMethod != null);
replaceRegexMethod.SetTransformedName("replace");
}
}
private void ImportMethods(TypeSymbol typeSymbol)
{
// NOTE: We do not import parameters for imported members.
// Parameters are used in the script model generation phase to populate
// symbol tables, which is not done for imported methods.
TypeDefinition type = (TypeDefinition)typeSymbol.MetadataReference;
foreach (MethodDefinition method in type.Methods) {
if (method.IsSpecialName) {
continue;
}
if (method.IsPrivate || method.IsAssembly || method.IsFamilyAndAssembly) {
continue;
}
string methodName = method.Name;
if (typeSymbol.GetMember(methodName) != null) {
// Ignore if its an overload since we don't care about parameters
// for imported methods, overloaded ctors don't matter.
// We just care about return values pretty much, and existence of the
// method.
continue;
}
TypeSymbol returnType = ResolveType(method.MethodReturnType.ReturnType);
if (returnType == null) {
continue;
}
MethodSymbol methodSymbol = new MethodSymbol(methodName, typeSymbol, returnType);
ImportMemberDetails(methodSymbol, method, method);
if (method.HasGenericParameters) {
List<GenericParameterSymbol> genericArguments = new List<GenericParameterSymbol>();
foreach (GenericParameter genericParameter in method.GenericParameters) {
GenericParameterSymbol arg =
new GenericParameterSymbol(genericParameter.Position, genericParameter.Name,
/* typeArgument */ false,
_symbols.GlobalNamespace);
genericArguments.Add(arg);
}
methodSymbol.AddGenericArguments(genericArguments);
}
if (method.IsAbstract) {
// NOTE: We're ignoring the override scenario - it doesn't matter in terms
// of the compilation and code generation
methodSymbol.SetImplementationState(SymbolImplementationFlags.Abstract);
}
if (MetadataHelpers.ShouldSkipFromScript(method)) {
methodSymbol.SetSkipGeneration();
}
if ((methodSymbol.Visibility & MemberVisibility.Static) != 0) {
string alias = MetadataHelpers.GetScriptAlias(method);
if (String.IsNullOrEmpty(alias) == false) {
methodSymbol.SetAlias(alias);
}
}
ICollection<string> conditions;
if (MetadataHelpers.ShouldTreatAsConditionalMethod(method, out conditions)) {
methodSymbol.SetConditions(conditions);
}
typeSymbol.AddMember(methodSymbol);
}
}
private void ImportDelegateInvoke(TypeSymbol delegateTypeSymbol)
{
TypeDefinition type = (TypeDefinition)delegateTypeSymbol.MetadataReference;
foreach (MethodDefinition method in type.Methods) {
if (String.CompareOrdinal(method.Name, "Invoke") != 0) {
continue;
}
TypeSymbol returnType = ResolveType(method.MethodReturnType.ReturnType);
Debug.Assert(returnType != null);
if (returnType == null) {
continue;
}
MethodSymbol methodSymbol = new MethodSymbol("Invoke", delegateTypeSymbol, returnType, MemberVisibility.Public);
methodSymbol.SetImplementationState(SymbolImplementationFlags.Abstract);
methodSymbol.SetTransformedName(String.Empty);
delegateTypeSymbol.AddMember(methodSymbol);
}
}
public DelegateExpression(Expression objectReference, MethodSymbol method)
: base(ExpressionType.Delegate, method.AssociatedType, SymbolFilter.Public | SymbolFilter.InstanceMembers)
{
_method = method;
_objectReference = objectReference;
}
private static void GenerateMethodComment(ScriptTextWriter writer, MethodSymbol methodSymbol) {
GenerateSummaryComment(writer, methodSymbol);
if (methodSymbol.Parameters != null) {
foreach (ParameterSymbol parameterSymbol in methodSymbol.Parameters) {
GenerateParameterComment(writer, parameterSymbol);
}
}
GenerateReturnsComment(writer, methodSymbol.AssociatedType);
}
public SymbolImplementation BuildMethod(MethodSymbol methodSymbol)
{
BlockStatementNode methodBody = ((MethodDeclarationNode)methodSymbol.ParseContext).Implementation;
return BuildImplementation((ISymbolTable)methodSymbol.Parent,
methodSymbol, methodBody, /* addAllParameters */ true);
}
private void DumpMethod(MethodSymbol methodSymbol)
{
_writer.Write("Abstract: ");
_writer.WriteLine(methodSymbol.IsAbstract);
if (methodSymbol.Conditions != null) {
_writer.WriteLine("Conditions:");
_writer.Indent++;
foreach (string condition in methodSymbol.Conditions) {
_writer.WriteLine(condition);
}
_writer.Indent--;
}
if (methodSymbol.Parameters != null) {
_writer.WriteLine("Parameters:");
_writer.Indent++;
foreach (ParameterSymbol paramSymbol in methodSymbol.Parameters) {
DumpSymbol(paramSymbol);
}
_writer.Indent--;
}
}
