Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/Compilation/CodeDOMUtility.cs

@@ -0,0 +1,384 @@
+//------------------------------------------------------------------------------
+// <copyright file="CodeDomUtility.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+namespace System.Web.Compilation {
+
+using System.Text;
+using System.Runtime.Serialization.Formatters;
+using System.ComponentModel;
+using System.ComponentModel.Design.Serialization;
+using System;
+using System.Collections;
+using System.Reflection;
+using System.IO;
+using System.Globalization;
+using System.Web.Util;
+using System.Web.UI;
+using System.Web.Configuration;
+using System.Diagnostics;
+using Debug = System.Diagnostics.Debug;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using Util = System.Web.UI.Util;
+
+internal static class CodeDomUtility {
+
+    internal static BooleanSwitch WebFormsCompilation = new BooleanSwitch("WebFormsCompilation", "Outputs information about the WebForms compilation of ASPX templates");
+
+    internal /*public*/ static CodeExpression GenerateExpressionForValue(PropertyInfo propertyInfo, object value, Type valueType) {
+#if DEBUG
+        if (WebFormsCompilation.Enabled) {
+            Debug.WriteLine("GenerateExpressionForValue() {");
+            Debug.Indent();
+        }
+#endif // DEBUG
+        CodeExpression rightExpr = null;
+
+        if (valueType == null) {
+            throw new ArgumentNullException("valueType");
+        }
+
+        PropertyDescriptor pd = null;
+        if (propertyInfo != null) {
+            pd = TypeDescriptor.GetProperties(propertyInfo.ReflectedType)[propertyInfo.Name];
+        }
+
+        if (valueType == typeof(string) && value is string) {
+            if (WebFormsCompilation.Enabled) Debug.WriteLine("simple string");
+            rightExpr = new CodePrimitiveExpression((string)value);
+        }
+        else if (valueType.IsPrimitive) {
+            if (WebFormsCompilation.Enabled) Debug.WriteLine("primitive");
+            rightExpr = new CodePrimitiveExpression(value);
+        }
+        else if (propertyInfo == null && valueType == typeof(object) &&
+            (value == null || value.GetType().IsPrimitive)) {
+
+            // If the type is object, and the value is a primitive, simply use a
+            // CodePrimitiveExpression instead of trying to use a TypeConverter (VSWhidbey 518773)
+            if (WebFormsCompilation.Enabled) Debug.WriteLine("primitive to object");
+            rightExpr = new CodePrimitiveExpression(value);
+        }
+        else if (valueType.IsArray) {
+            if (WebFormsCompilation.Enabled) Debug.WriteLine("array");
+            Array array = (Array)value;
+            CodeArrayCreateExpression exp = new CodeArrayCreateExpression();
+            exp.CreateType = new CodeTypeReference(valueType.GetElementType());
+            if (array != null) {
+                foreach (object o in array) {
+                    exp.Initializers.Add(GenerateExpressionForValue(null, o, valueType.GetElementType()));
+                }
+            }
+            rightExpr = exp;
+        }
+        else if (valueType == typeof(Type)) {
+            rightExpr = new CodeTypeOfExpression((Type) value);
+        }
+        else {
+            if (WebFormsCompilation.Enabled) Debug.WriteLine("other");
+            TypeConverter converter = null;
+            if (pd != null) {
+                converter = pd.Converter;
+            }
+            else {
+                converter = TypeDescriptor.GetConverter(valueType);
+            }
+
+            bool added = false;
+
+            if (converter != null) {
+                InstanceDescriptor desc = null;
+                
+                if (converter.CanConvertTo(typeof(InstanceDescriptor))) {
+                    desc = (InstanceDescriptor)converter.ConvertTo(value, typeof(InstanceDescriptor));
+                }
+                if (desc != null) {
+                    if (WebFormsCompilation.Enabled) Debug.WriteLine("has converter with instance descriptor");
+
+                    // static field ref...
+                    //
+                    if (desc.MemberInfo is FieldInfo) {
+                        if (WebFormsCompilation.Enabled) Debug.WriteLine("persistinfo is a field ref");
+                        CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
+                        rightExpr = fieldRef;
+                        added = true;
+                    }
+                    // static property ref
+                    else if (desc.MemberInfo is PropertyInfo) {
+                        if (WebFormsCompilation.Enabled) Debug.WriteLine("persistinfo is a property ref");
+                        CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
+                        rightExpr = propRef;
+                        added = true;
+                    }
+
+                    // static method invoke
+                    //
+                    else {
+                        object[] args = new object[desc.Arguments.Count];
+                        desc.Arguments.CopyTo(args, 0);
+                        CodeExpression[] expressions = new CodeExpression[args.Length];
+                        
+                        if (desc.MemberInfo is MethodInfo) {
+                            MethodInfo mi = (MethodInfo)desc.MemberInfo;
+                            ParameterInfo[] parameters = mi.GetParameters();
+                            
+                            for(int i = 0; i < args.Length; i++) {
+                                expressions[i] = GenerateExpressionForValue(null, args[i], parameters[i].ParameterType);
+                            }
+                            
+                            if (WebFormsCompilation.Enabled) Debug.WriteLine("persistinfo is a method invoke");
+                            CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
+                            foreach (CodeExpression e in expressions) {
+                                methCall.Parameters.Add(e);
+                            }
+                            rightExpr = new CodeCastExpression(valueType, methCall);
+                            added = true;
+                        }
+                        else if (desc.MemberInfo is ConstructorInfo) {
+                            ConstructorInfo ci = (ConstructorInfo)desc.MemberInfo;
+                            ParameterInfo[] parameters = ci.GetParameters();
+                            
+                            for(int i = 0; i < args.Length; i++) {
+                                expressions[i] = GenerateExpressionForValue(null, args[i], parameters[i].ParameterType);
+                            }
+                        
+                            if (WebFormsCompilation.Enabled) Debug.WriteLine("persistinfo is a constructor call");
+                            CodeObjectCreateExpression objectCreate = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName);
+                            foreach (CodeExpression e in expressions) {
+                                objectCreate.Parameters.Add(e);
+                            }
+                            rightExpr = objectCreate;
+                            added = true;
+                        }
+                    }
+                }
+            }
+
+            if (!added) {
+#if DEBUG
+                if (WebFormsCompilation.Enabled) {
+                    Debug.WriteLine("unabled to determine type, attempting Parse");
+                    Debug.Indent();
+                    Debug.WriteLine("value.GetType  == " + value.GetType().FullName);
+                    Debug.WriteLine("value.ToString == " + value.ToString());
+                    Debug.WriteLine("valueType      == " + valueType.FullName);
+                    if (propertyInfo != null) {
+                        Debug.WriteLine("propertyInfo   == " + propertyInfo.ReflectedType.FullName + "." + propertyInfo.Name + " : " + propertyInfo.PropertyType.FullName);
+                    }
+                    else {
+                        Debug.WriteLine("propertyInfo   == (null)");
+                    }
+
+                    Debug.Unindent();
+                }
+#endif // DEBUG
+
+
+                // Not a known type: try calling Parse
+
+                // If possible, pass it an InvariantCulture (ASURT 79412)
+                if (valueType.GetMethod("Parse", new Type[] {typeof(string), typeof(CultureInfo)}) != null) {
+                    CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(valueType.FullName), "Parse");
+
+                    // Convert the object to a string.
+                    // If we have a type converter, use it to convert to a string in a culture
+                    // invariant way (ASURT 87094)
+                    string s;
+                    if (converter != null) {
+                        s = converter.ConvertToInvariantString(value);
+                    }
+                    else {
+                        s = value.ToString();
+                    }
+
+                    methCall.Parameters.Add(new CodePrimitiveExpression(s));
+                    methCall.Parameters.Add(new CodePropertyReferenceExpression(BuildGlobalCodeTypeReferenceExpression(typeof(CultureInfo)), "InvariantCulture"));
+                    rightExpr = methCall;
+
+                }
+                else if (valueType.GetMethod("Parse", new Type[] {typeof(string)}) != null) {
+                    // Otherwise, settle for passing just the string
+                    CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(valueType.FullName), "Parse");
+                    methCall.Parameters.Add(new CodePrimitiveExpression(value.ToString()));
+                    rightExpr = methCall;
+
+                }
+                else {
+                    throw new HttpException(SR.GetString(SR.CantGenPropertySet, propertyInfo.Name, valueType.FullName));
+                }
+            }
+        }
+
+#if DEBUG
+        if (WebFormsCompilation.Enabled) {
+            Debug.Unindent();
+            Debug.WriteLine("}");
+        }
+#endif // DEBUG
+        return rightExpr;
+    }
+
+    // Adds a property assignment statement to "statements". This takes into account
+    // checking for nulls when the destination property type is a value type. This can
+    // also generate expressions that use IAttributeAccessor when desinationType is null.
+    internal static void CreatePropertySetStatements(CodeStatementCollection methodStatements, CodeStatementCollection statements,
+        CodeExpression target, string targetPropertyName, Type destinationType,
+        CodeExpression value,
+        CodeLinePragma linePragma) {
+        // Generates:
+        // If destination is property:
+        //     If destination type is string:
+        //         {{target}}.{{targetPropertyName}} = System.Convert.ToString( {{value}} );
+        //     Else If destination type is reference type:
+        //         {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) {{value}};
+        //     Else destination type is value type:
+        //         {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) ({value});
+        // Else use SetAttribute (expandos):
+        //     ((IAttributeAccessor) {{target}} ).SetAttribute( {{targetPropertyName}} , System.Convert.ToString( {{value}} ));
+
+        bool useSetAttribute = false;
+        // This signifies it's using SetAttribute
+        if (destinationType == null) {
+            useSetAttribute = true;
+        }
+
+        if (useSetAttribute) {
+            // ((IAttributeAccessor) {{target}} ).SetAttribute( {{targetPropertyName}} , System.Convert.ToString( {{value}} ));
+            CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
+            CodeExpressionStatement setAttributeCall = new CodeExpressionStatement(methodInvoke);
+            setAttributeCall.LinePragma = linePragma;
+
+            // Dev11 128332: Ensure style attribute on html control is lowercase as required for xhtml validation
+            if (targetPropertyName.Equals("Style", StringComparison.Ordinal)) {
+                targetPropertyName = "style";
+            }
+
+            methodInvoke.Method.TargetObject = new CodeCastExpression(typeof(IAttributeAccessor), target);
+            methodInvoke.Method.MethodName = "SetAttribute";
+            methodInvoke.Parameters.Add(new CodePrimitiveExpression(targetPropertyName));
+
+            methodInvoke.Parameters.Add(GenerateConvertToString(value));
+
+            statements.Add(setAttributeCall);
+        }
+        else {
+            // Use the property setter. Must take into account that null cannot be
+            // cast to a value type, so we have to explicitly check for that in
+            // the code we generate.
+
+            if (destinationType.IsValueType) {
+                //         {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) ({value});
+                CodeAssignStatement assignStmt = new CodeAssignStatement(
+                        BuildPropertyReferenceExpression(target, targetPropertyName),
+                        new CodeCastExpression(destinationType, value));
+                assignStmt.LinePragma = linePragma;
+                statements.Add(assignStmt);
+            }
+            else {
+                CodeExpression rightSide;
+
+                if (destinationType == typeof(string)) {
+                    // {{target}}.{{targetPropertyName}} = System.Convert.ToString( {{value}} );
+                    rightSide = GenerateConvertToString(value);
+                }
+                else {
+                    // {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) {{value}};
+                    rightSide = new CodeCastExpression(destinationType, value);
+                }
+
+                CodeAssignStatement assignStmt = new CodeAssignStatement(
+                    BuildPropertyReferenceExpression(target, targetPropertyName),
+                    rightSide);
+                assignStmt.LinePragma = linePragma;
+                statements.Add(assignStmt);
+            }
+        }
+    }
+
+    // Generate a call to System.Convert.ToString(value, CultureInfo.CurrentCulture)
+    internal static CodeExpression GenerateConvertToString(CodeExpression value) {
+
+        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
+        invokeExpr.Method.TargetObject = BuildGlobalCodeTypeReferenceExpression(typeof(System.Convert));
+        invokeExpr.Method.MethodName = "ToString";
+        invokeExpr.Parameters.Add(value);
+        invokeExpr.Parameters.Add(new CodePropertyReferenceExpression(
+            BuildGlobalCodeTypeReferenceExpression(typeof(CultureInfo)), "CurrentCulture"));
+
+        return invokeExpr;
+    }
+
+    // Prepend a string TO the CompilerOptions string
+    internal static void PrependCompilerOption(
+        CompilerParameters compilParams, string compilerOptions) {
+
+        if (compilParams.CompilerOptions == null)
+            compilParams.CompilerOptions = compilerOptions;
+        else
+            compilParams.CompilerOptions = compilerOptions + " " + compilParams.CompilerOptions;
+    }
+
+    // Append a string to the CompilerOptions string
+    internal static void AppendCompilerOption(
+        CompilerParameters compilParams, string compilerOptions) {
+
+        if (compilParams.CompilerOptions == null)
+            compilParams.CompilerOptions = compilerOptions;
+        else
+            compilParams.CompilerOptions = compilParams.CompilerOptions + " " + compilerOptions;
+    }
+
+    internal static CodeExpression BuildPropertyReferenceExpression(
+        CodeExpression objRefExpr, string propName) {
+
+        // The name may contain several '.' separated properties, so we
+        // need to make sure we build the CodeDom accordingly (ASURT 91875, VSWhidbey 313018)
+        string[] parts = propName.Split('.');
+        CodeExpression ret = objRefExpr;
+        foreach (string part in parts)
+            ret = new CodePropertyReferenceExpression(ret, part);
+
+        return ret;
+    }
+
+    internal static CodeCastExpression BuildJSharpCastExpression(Type castType, CodeExpression expression) {
+        
+        // VJ# does not support automatic boxing of value types, so passing a simple type, say a bool, into a method
+        // expecting an object will give a compiler error.  We are working around this issue by adding special code for
+        // VJ# that will cast the expression for boxing.  When the VJ# team adds implicit boxing of value types, we
+        // should remove this code.  VSWhidbey 269028
+        CodeCastExpression castedExpression = new CodeCastExpression(castType, expression); 
+        castedExpression.UserData.Add("CastIsBoxing", true);
+        return castedExpression;
+    }
+
+    internal static CodeTypeReference BuildGlobalCodeTypeReference(string typeName) {
+        return new CodeTypeReference(typeName, CodeTypeReferenceOptions.GlobalReference);
+    }
+
+    internal static CodeTypeReference BuildGlobalCodeTypeReference(Type type) {
+        return new CodeTypeReference(type, CodeTypeReferenceOptions.GlobalReference);
+    }
+
+    private static CodeTypeReferenceExpression BuildGlobalCodeTypeReferenceExpression(string typeName) {
+        // Returns an expression that resolves the type name from the root namespace, 
+        // eg global::Namespace.TypeName
+        CodeTypeReference codeTypeReference = BuildGlobalCodeTypeReference(typeName);
+        CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(codeTypeReference);
+        return codeTypeReferenceExpression;
+    }
+
+    private static CodeTypeReferenceExpression BuildGlobalCodeTypeReferenceExpression(Type type) {
+        // Returns an expression that resolves the type name from the root namespace, 
+        // eg global::Namespace.TypeName
+        CodeTypeReference codeTypeReference = BuildGlobalCodeTypeReference(type);
+        CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(codeTypeReference);
+        return codeTypeReferenceExpression;
+    }
+
+}
+}
+