internal void Identifier(string name, TypeReferenceContext context, bool includeParens = false) { if (context == null) { throw new ArgumentNullException("context"); } Identifier(name); }
public void Identifier(TypeReference type, TypeReferenceContext context, bool includeParens = false) { if (type.FullName == "JSIL.Proxy.AnyType") { WriteRaw("JSIL.AnyType"); } else { TypeIdentifier(type as dynamic, context, includeParens); } }
public void Identifier(ILVariable variable, TypeReferenceContext context, bool includeParens = false) { if (variable.Type.IsByReference) { throw new NotImplementedException("Old-style use of JavascriptFormatter.Identifier on a ref variable"); } else { Identifier(variable.Name); } }
protected void TypeReferenceInternal(ArrayType at, TypeReferenceContext context) { WriteRaw("$jsilcore"); Dot(); WriteRaw("TypeRef"); LPar(); Value("System.Array"); Comma(); OpenBracket(); TypeReference(at.ElementType, context); CloseBracket(); RPar(); }
public void Identifier(ILVariable variable, TypeReferenceContext context, bool includeParens = false) { if (variable.Type.IsByReference) { Identifier(variable.Name); Dot(); Identifier("value"); } else { Identifier(variable.Name); } }
protected void TypeReferenceInternal(PointerType pt, TypeReferenceContext context) { WriteRaw("$jsilcore"); Dot(); WriteRaw("TypeRef"); LPar(); Value("JSIL.Pointer"); Comma(); OpenBracket(false); TypeReference(pt.ElementType, context); CloseBracket(false); RPar(); }
protected void TypeReferenceInternal(ByReferenceType byref, TypeReferenceContext context) { WriteRaw("$jsilcore"); Dot(); WriteRaw("TypeRef"); LPar(); Value("JSIL.Reference"); Comma(); OpenBracket(false); TypeReference(byref.ElementType, context); CloseBracket(false); RPar(); }
protected void TypeIdentifier(ArrayType type, TypeReferenceContext context, bool includeParens) { if (includeParens) { LPar(); } WriteRaw("System.Array.Of"); LPar(); TypeIdentifier(type.ElementType as dynamic, context, false); RPar(); if (includeParens) { RPar(); Space(); } }
protected void TypeIdentifier(GenericInstanceType type, TypeReferenceContext context, bool includeParens) { if (includeParens) { LPar(); } Identifier(type.ElementType as dynamic, context, includeParens); Dot(); WriteRaw("Of"); LPar(); CommaSeparatedList(type.GenericArguments, context, ListValueType.TypeIdentifier); RPar(); if (includeParens) { RPar(); Space(); } }
protected void TypeReferenceInternal(GenericParameter gp, TypeReferenceContext context) { var ownerType = gp.Owner as TypeReference; var ownerMethod = gp.Owner as MethodReference; if (context != null) { if (ownerType != null) { if (TypeUtil.TypesAreAssignable(TypeInfo, ownerType, context.SignatureMethodType)) { var resolved = JSIL.Internal.MethodSignature.ResolveGenericParameter(gp, context.SignatureMethodType); if (resolved != null) { if (resolved != gp) { TypeReference(resolved, context); return; } else { TypeIdentifier(resolved, context, false); return; } } } if (TypeUtil.TypesAreEqual(ownerType, context.EnclosingMethodType)) { TypeIdentifier(gp, context, false); return; } if (TypeUtil.TypesAreEqual(ownerType, context.DefiningType)) { OpenGenericParameter(gp, context.DefiningType.FullName); return; } if (TypeUtil.TypesAreEqual(ownerType, context.EnclosingType)) { LocalOpenGenericParameter(gp); return; } var ownerTypeResolved = ownerType.Resolve(); if (ownerTypeResolved != null) { // Is it a generic parameter of a compiler-generated class (i.e. enumerator function, delegate, etc) // nested inside our EnclosingType? If so, uhhhh, shit. if ( TypeUtil.TypesAreEqual(context.EnclosingType, ownerTypeResolved.DeclaringType) && ownerTypeResolved.CustomAttributes.Any( (ca) => ca.AttributeType.FullName == "System.Runtime.CompilerServices.CompilerGeneratedAttribute" ) ) { // FIXME: I HAVE NO IDEA WHAT I AM DOING OpenGenericParameter(gp, ownerTypeResolved.FullName); return; } } throw new NotImplementedException(String.Format( "Unimplemented form of generic type parameter: '{0}'.", gp )); } else if (ownerMethod != null) { Func <MethodReference, int> getPosition = (mr) => { for (var i = 0; i < mr.GenericParameters.Count; i++) { if (mr.GenericParameters[i].Name == gp.Name) { return(i); } } throw new NotImplementedException(String.Format( "Generic parameter '{0}' not found in method '{1}' parameter list", gp, ownerMethod )); }; var ownerMethodIdentifier = new QualifiedMemberIdentifier( new TypeIdentifier(ownerMethod.DeclaringType.Resolve()), new MemberIdentifier(TypeInfo, ownerMethod) ); if (ownerMethodIdentifier.Equals(ownerMethod, context.InvokingMethod, TypeInfo)) { var gim = (GenericInstanceMethod)context.InvokingMethod; TypeReference(gim.GenericArguments[getPosition(ownerMethod)], context); return; } if (ownerMethodIdentifier.Equals(ownerMethod, context.EnclosingMethod, TypeInfo)) { Identifier(gp.Name); return; } if ( ownerMethodIdentifier.Equals(ownerMethod, context.DefiningMethod, TypeInfo) || ownerMethodIdentifier.Equals(ownerMethod, context.SignatureMethod, TypeInfo) ) { Value(String.Format("!!{0}", getPosition(ownerMethod))); return; } throw new NotImplementedException(String.Format( "Unimplemented form of generic method parameter: '{0}'.", gp )); } } else { throw new NotImplementedException("Cannot resolve generic parameter without a TypeReferenceContext."); } throw new NotImplementedException(String.Format( "Unimplemented form of generic parameter: '{0}'.", gp )); }
public void CommaSeparatedList(IEnumerable <TypeReference> types, TypeReferenceContext context) { CommaSeparatedListCore( types, (type) => TypeReference(type, context) ); }
internal void Identifier(string name, TypeReferenceContext context, bool includeParens = false) { Identifier(name); }
public void ConstructorSignature(MethodReference method, MethodSignature signature, TypeReferenceContext context) { Signature(method, signature, context, true, true); }
protected void TypeIdentifier(PointerType ptr, TypeReferenceContext context, bool includeParens) { Identifier(ptr.ElementType as dynamic, context, includeParens); }
protected void TypeIdentifier(RequiredModifierType modreq, TypeReferenceContext context, bool includeParens) { Identifier(modreq.ElementType as dynamic, context, includeParens); }
protected void TypeIdentifier(OptionalModifierType modopt, TypeReferenceContext context, bool includeParens) { Identifier(modopt.ElementType as dynamic, context, includeParens); }
public void TypeReference(TypeReference type, TypeReferenceContext context) { if ( (context != null) && (context.EnclosingType != null) ) { if (TypeUtil.TypesAreEqual(type, context.EnclosingType)) { // Types can reference themselves, so this prevents recursive initialization. if (Stubbed && Configuration.GenerateSkeletonsForStubbedAssemblies.GetValueOrDefault(false)) { } else { WriteRaw("$.Type"); return; } } // The interface builder provides helpful shorthand for corlib type references. if (type.Scope.Name == "mscorlib" || type.Scope.Name == "CommonLanguageRuntimeLibrary") { if (CorlibTypes.Contains(type.FullName)) { WriteRaw("$."); WriteRaw(type.Name); return; } } } if (type.FullName == "JSIL.Proxy.AnyType") { Value("JSIL.AnyType"); return; } else if (type.FullName == "JSIL.Proxy.AnyType[]") { TypeReference(TypeUtil.GetTypeDefinition(type), context); Space(); Comment("AnyType[]"); return; } var byref = type as ByReferenceType; var gp = type as GenericParameter; var at = type as ArrayType; var pt = type as PointerType; if (byref != null) { TypeReferenceInternal(byref, context); } else if (gp != null) { TypeReferenceInternal(gp, context); } else if (at != null) { TypeReferenceInternal(at, context); } else if (pt != null) { TypeReferenceInternal(pt, context); } else { TypeReferenceInternal(type, context); } }
protected void TypeIdentifier(TypeInfo type, TypeReferenceContext context, bool includeParens) { TypeIdentifier(type.Definition as dynamic, context, includeParens); }
public void TypeReference(TypeInfo type, TypeReferenceContext context) { TypeReference(type.Definition, context); }
public void MethodSignature(MethodReference method, MethodSignature signature, TypeReferenceContext context) { // The signature cache can cause problems inside methods for generic signatures. var cached = Configuration.Optimizer.CacheMethodSignatures.GetValueOrDefault(true); // We also don't want to use the cache for method definitions in skeletons. if (Stubbed && Configuration.GenerateSkeletonsForStubbedAssemblies.GetValueOrDefault(false)) { cached = false; } if (cached && ((context.InvokingMethod != null) || (context.EnclosingMethod != null))) { if (TypeUtil.IsOpenType(signature.ReturnType)) { cached = false; } else if (signature.ParameterTypes.Any(TypeUtil.IsOpenType)) { cached = false; } } if (cached) { WriteRaw("$sig.get"); LPar(); Value(signature.ID); Comma(); } else { LPar(); WriteRaw("new JSIL.MethodSignature"); LPar(); } var oldSignature = context.SignatureMethod; context.SignatureMethod = method; try { if ((signature.ReturnType == null) || (signature.ReturnType.FullName == "System.Void")) { WriteRaw("null"); } else { if ((context.EnclosingMethod != null) && !TypeUtil.IsOpenType(signature.ReturnType)) { TypeIdentifier(signature.ReturnType as dynamic, context, false); } else { TypeReference(signature.ReturnType, context); } } Comma(); OpenBracket(false); CommaSeparatedListCore( signature.ParameterTypes, (pt) => { if ((context.EnclosingMethod != null) && !TypeUtil.IsOpenType(pt)) { TypeIdentifier(pt as dynamic, context, false); } else { TypeReference(pt, context); } } ); CloseBracket(false); if (signature.GenericParameterNames != null) { Comma(); OpenBracket(false); CommaSeparatedList(signature.GenericParameterNames, context, ListValueType.Primitive); CloseBracket(false); } } finally { context.SignatureMethod = oldSignature; } RPar(); if (!cached) { RPar(); } }
public void MethodSignature(MethodReference method, MethodSignature signature, TypeReferenceContext context) { Signature(method, signature, context, false, true); }
protected void TypeReferenceInternal(GenericParameter gp, TypeReferenceContext context) { var ownerType = gp.Owner as TypeReference; var ownerMethod = gp.Owner as MethodReference; if (context != null) { if (ownerType != null) { if (TypeUtil.TypesAreAssignable(TypeInfo, ownerType, context.SignatureMethodType)) { TypeReference resolved = null; var git = (context.SignatureMethodType as GenericInstanceType); if (git != null) { for (var i = 0; i < git.ElementType.GenericParameters.Count; i++) { var _ = git.ElementType.GenericParameters[i]; if ((_.Name == gp.Name) || (_.Position == gp.Position)) { resolved = git.GenericArguments[i]; break; } } if (resolved == null) { throw new NotImplementedException(String.Format( "Could not find generic parameter '{0}' in type {1}", gp, context.SignatureMethodType )); } } if (resolved != null) { if (resolved != gp) { TypeReference(resolved, context); return; } else { TypeIdentifier(resolved, context, false); return; } } } if (TypeUtil.TypesAreEqual(ownerType, context.EnclosingMethodType)) { TypeIdentifier(gp, context, false); return; } if (TypeUtil.TypesAreEqual(ownerType, context.DefiningType)) { OpenGenericParameter(gp.Name, context.DefiningType.FullName); return; } if (TypeUtil.TypesAreEqual(ownerType, context.EnclosingType)) { WriteRaw("$.GenericParameter"); LPar(); Value(gp.Name); RPar(); return; } throw new NotImplementedException(String.Format( "Unimplemented form of generic type parameter: '{0}'.", gp )); } else if (ownerMethod != null) { Func <MethodReference, int> getPosition = (mr) => { for (var i = 0; i < mr.GenericParameters.Count; i++) { if (mr.GenericParameters[i].Name == gp.Name) { return(i); } } throw new NotImplementedException(String.Format( "Generic parameter '{0}' not found in method '{1}' parameter list", gp, ownerMethod )); }; var ownerMethodIdentifier = new QualifiedMemberIdentifier( new TypeIdentifier(ownerMethod.DeclaringType), new MemberIdentifier(TypeInfo, ownerMethod) ); if (ownerMethodIdentifier.Equals(ownerMethod, context.InvokingMethod, TypeInfo)) { var gim = (GenericInstanceMethod)context.InvokingMethod; TypeReference(gim.GenericArguments[getPosition(ownerMethod)], context); return; } if (ownerMethodIdentifier.Equals(ownerMethod, context.DefiningMethod, TypeInfo)) { Value(String.Format("!!{0}", getPosition(ownerMethod))); return; } if (ownerMethodIdentifier.Equals(ownerMethod, context.EnclosingMethod, TypeInfo)) { throw new NotImplementedException(String.Format( "Unimplemented form of generic method parameter: '{0}'.", gp )); } Value(String.Format("!!{0}", getPosition(ownerMethod))); return; } } else { throw new NotImplementedException("Cannot resolve generic parameter without a TypeReferenceContext."); } throw new NotImplementedException(String.Format( "Unimplemented form of generic parameter: '{0}'.", gp )); }
protected void TypeIdentifier(TypeReference type, TypeReferenceContext context, bool includeParens) { if (type.FullName == "JSIL.Proxy.AnyType") { WriteRaw("JSIL.AnyType"); return; } if (TypeUtil.TypesAreEqual(context.EnclosingType, type, true)) { WriteRaw("$thisType"); return; } if (type.IsGenericParameter) { var gp = (GenericParameter)type; var ownerType = gp.Owner as TypeReference; if (gp.Owner == null) { Value(gp.Name); } else if ( (CurrentMethod != null) && ((CurrentMethod.Equals(gp.Owner)) || (CurrentMethod.DeclaringType.Equals(gp.Owner)) ) ) { if (ownerType != null) { Identifier(ownerType, context); Dot(); Identifier(gp.Name); Dot(); Identifier("get"); LPar(); WriteRaw("this"); RPar(); } else { Identifier(gp.Name); } } else { if (EmitThisForParameter(gp)) { WriteRaw("this"); Dot(); } Identifier(type.FullName); } } else { var info = TypeInfo.Get(type); if ((info != null) && (info.Replacement != null)) { WriteRaw(info.Replacement); return; } var typedef = type.Resolve(); if (typedef != null) { if (GetContainingAssemblyName(typedef) == Assembly.FullName) { WriteToken(PrivateToken); WriteRaw("."); } else { AssemblyReference(typedef); WriteRaw("."); } } if (info != null) { WriteRaw(Util.EscapeIdentifier( info.FullName, EscapingMode.TypeIdentifier )); } else { // FIXME: Is this right? WriteRaw(Util.EscapeIdentifier( type.FullName, EscapingMode.TypeIdentifier )); } } }
public void Signature(MethodReference method, MethodSignature signature, TypeReferenceContext context, bool forConstructor, bool allowCache) { if (forConstructor) { WriteRaw("new JSIL.ConstructorSignature"); } else { WriteRaw("new JSIL.MethodSignature"); } LPar(); var oldSignature = context.SignatureMethod; context.SignatureMethod = method; try { if (forConstructor) { TypeReference(method.DeclaringType, context); Comma(); } else { if ((signature.ReturnType == null) || (signature.ReturnType.FullName == "System.Void")) { WriteRaw("null"); } else { if ((context.EnclosingMethod != null) && !TypeUtil.IsOpenType(signature.ReturnType)) { TypeIdentifier(signature.ReturnType as dynamic, context, false); } else { TypeReference(signature.ReturnType, context); } } Comma(); } OpenBracket(false); CommaSeparatedListCore( signature.ParameterTypes, (pt) => { if ((context.EnclosingMethod != null) && !TypeUtil.IsOpenType(pt)) { TypeIdentifier(pt as dynamic, context, false); } else { TypeReference(pt, context); } } ); CloseBracket(false); if (!forConstructor && (signature.GenericParameterNames != null)) { Comma(); OpenBracket(false); CommaSeparatedList(signature.GenericParameterNames, context, ListValueType.Primitive); CloseBracket(false); } } finally { context.SignatureMethod = oldSignature; } RPar(); }