/// <summary>
/// Writes an interface member reference to the output.
/// </summary>
public void WriteInterfaceMemberToOutput(
JavascriptFormatter output, Compiler.Extensibility.IAstEmitter astEmitter,
JSFunctionExpression enclosingFunction,
JSMethod jsMethod, JSExpression method,
TypeReferenceContext referenceContext
)
{
int index;
CachedInterfaceMemberRecord record;
GenericParameter[] rewrittenGenericParameters = null;
if (LocalCachingEnabled && PreferLocalCacheForGenericInterfaceMethodSignatures)
{
record = new CachedInterfaceMemberRecord(jsMethod.Reference.DeclaringType, jsMethod.Identifier);
}
else
{
var rewritten = GenericTypesRewriter.Normalized(jsMethod.Reference.DeclaringType);
record = new CachedInterfaceMemberRecord(rewritten.CacheRecord, jsMethod.Identifier,
rewritten.RewritedGenericParameters.Length);
rewrittenGenericParameters = rewritten.RewritedGenericParameters;
}
if (enclosingFunction.Method != null && enclosingFunction.Method.Method != null)
{
var functionIdentifier = enclosingFunction.Method.Method.Identifier;
CacheSet localSignatureSet;
if (LocalCachedSets.TryGetValue(functionIdentifier, out localSignatureSet))
{
if (localSignatureSet.InterfaceMembers.TryGetValue(record, out index))
{
output.WriteRaw("$im{0:X2}", index);
return;
}
}
}
if (!Global.InterfaceMembers.TryGetValue(record, out index))
{
output.Identifier(jsMethod.Reference.DeclaringType, referenceContext, false);
output.Dot();
astEmitter.Emit(method);
}
else
{
output.WriteRaw("$IM{0:X2}", index);
output.LPar();
if (rewrittenGenericParameters != null)
{
output.CommaSeparatedList(rewrittenGenericParameters, referenceContext);
}
output.RPar();
}
}
/// <summary>
/// Writes a method signature to the output.
/// </summary>
public void WriteSignatureToOutput(
JavascriptFormatter output, JSFunctionExpression enclosingFunction,
MethodReference methodReference, MethodSignature methodSignature,
TypeReferenceContext referenceContext,
bool forConstructor
)
{
int index;
CachedSignatureRecord cacheRecord;
GenericParameter[] rewrittenGenericParameters = null;
if (LocalCachingEnabled && PreferLocalCacheForGenericMethodSignatures)
{
cacheRecord = new CachedSignatureRecord(methodReference,
GenericTypesRewriter.NormalizedConstructorSignature(methodReference, methodSignature, forConstructor),
forConstructor);
}
else
{
RewritedCacheRecord <MethodSignature> rewritten = GenericTypesRewriter.Normalized(methodReference,
methodSignature, forConstructor);
cacheRecord = new CachedSignatureRecord(methodReference, rewritten.CacheRecord, forConstructor,
rewritten.RewritedGenericParameters.Length);
rewrittenGenericParameters = rewritten.RewritedGenericParameters;
}
if ((enclosingFunction.Method != null) && (enclosingFunction.Method.Method != null))
{
var functionIdentifier = enclosingFunction.Method.Method.Identifier;
CacheSet localSignatureSet;
if (LocalCachedSets.TryGetValue(functionIdentifier, out localSignatureSet))
{
if (localSignatureSet.Signatures.TryGetValue(cacheRecord, out index))
{
output.WriteRaw("$s{0:X2}", index);
return;
}
}
}
if (!Global.Signatures.TryGetValue(cacheRecord, out index))
{
output.Signature(methodReference, methodSignature, referenceContext, forConstructor, true);
}
else
{
output.WriteRaw("$S{0:X2}", index);
output.LPar();
if (rewrittenGenericParameters != null)
{
output.CommaSeparatedList(rewrittenGenericParameters, referenceContext);
}
output.RPar();
}
}
private void CacheInterfaceMember(TypeReference declaringType, string memberName)
{
var cacheLocally = false;
var originalType = declaringType;
var unexpandedType = declaringType;
if (!TypeUtil.ExpandPositionalGenericParameters(unexpandedType, out declaringType))
{
declaringType = unexpandedType;
}
CachedInterfaceMemberRecord record;
if (LocalCachingEnabled && PreferLocalCacheForGenericInterfaceMethodSignatures)
{
if (TypeUtil.IsOpenType(declaringType))
{
cacheLocally = true;
}
record = new CachedInterfaceMemberRecord(declaringType, memberName);
}
else
{
var rewritten = GenericTypesRewriter.Normalized(declaringType);
record = new CachedInterfaceMemberRecord(rewritten.CacheRecord, memberName,
rewritten.RewritedGenericParameters.Length);
}
var set = GetCacheSet(cacheLocally);
if (!set.InterfaceMembers.ContainsKey(record))
{
set.InterfaceMembers.Add(record, set.InterfaceMembers.Count);
}
}
private void CacheSignature(MethodReference method, MethodSignature signature, bool isConstructor)
{
bool cacheLocally;
CachedSignatureRecord record;
if (LocalCachingEnabled && PreferLocalCacheForGenericMethodSignatures)
{
record = new CachedSignatureRecord(method,
GenericTypesRewriter.NormalizedConstructorSignature(method, signature, isConstructor), isConstructor);
signature = record.Signature;
Func <GenericParameter, bool> filter =
(gp) => {
// If the generic parameter can be expanded given the type that declared the method, don't cache locally.
var resolved = MethodSignature.ResolveGenericParameter(gp, method.DeclaringType);
// Note that we have to ensure the resolved type is not generic either. A generic parameter can resolve to a
// *different* generic parameter, and that is still correct - i.e. SomeMethod<A> calls SomeMethod<B>,
// in that case resolving B will yield A.
if ((resolved != gp) && (resolved != null) && !TypeUtil.IsOpenType(resolved))
{
return(false);
}
var ownerMethod = gp.Owner as MethodReference;
if (ownerMethod == null)
{
return(true);
}
if (ownerMethod == method)
{
return(false);
}
// FIXME: Nulls?
else if (ownerMethod.Resolve() == method.Resolve())
{
return(false);
}
else
{
return(true);
}
};
cacheLocally = false;
if (TypeUtil.IsOpenType(signature.ReturnType, filter))
{
cacheLocally = true;
}
else if (signature.ParameterTypes.Any((gp) => TypeUtil.IsOpenType(gp, filter)))
{
cacheLocally = true;
}
else if (isConstructor && TypeUtil.IsOpenType(method.DeclaringType, filter))
{
cacheLocally = true;
}
}
else
{
cacheLocally = false;
var rewritenInfo = GenericTypesRewriter.Normalized(method, signature, isConstructor);
record = new CachedSignatureRecord(
method,
rewritenInfo.CacheRecord,
isConstructor,
rewritenInfo.RewritedGenericParameters.Length);
}
var set = GetCacheSet(cacheLocally);
if (!set.Signatures.ContainsKey(record))
{
set.Signatures.Add(record, set.Signatures.Count);
}
}