private static bool TryTranslateDefault <T>(ConstantExpression constant, out ITranslation translation)
        {
            if ((constant.Type != typeof(T)) || !constant.Value.Equals(default(T)))
            {
                translation = null;
                return(false);
            }

            translation = new TranslationWrapper(FixedValueTranslation(typeof(T).Name, typeof(T))).WrappedWith("default(", ")");
            return(true);
        }
        private static bool TryGetRegexTranslation(ConstantExpression constant, out ITranslation translation)
        {
            if (constant.Type != typeof(Regex))
            {
                translation = null;
                return(false);
            }

            translation = FixedValueTranslation(constant);
            translation = new TranslationWrapper(translation).WrappedWith("Regex /* ", " */");
            return(true);
        }
        private static bool TryGetTypeTranslation(
            ConstantExpression constant,
            ITranslationContext context,
            out ITranslation translation)
        {
            if (!constant.Type.IsAssignableTo(typeof(Type)))
            {
                translation = null;
                return(false);
            }

            translation = context.GetTranslationFor((Type)constant.Value);
            translation = new TranslationWrapper(translation).WrappedWith("typeof(", ")");
            return(true);
        }
        private static bool TryTranslateFromTypeCode(
            ConstantExpression constant,
            ITranslationContext context,
            out ITranslation translation)
        {
            switch ((Nullable.GetUnderlyingType(constant.Type) ?? constant.Type).GetTypeCode())
            {
            case NetStandardTypeCode.Boolean:
                translation = FixedValueTranslation(constant.Value.ToString().ToLowerInvariant(), constant.Type);
                return(true);

            case NetStandardTypeCode.Char:
                var character = (char)constant.Value;
                var value     = character == '\0' ? Expression.Constant(@"\0") : constant;
                translation = new TranslationWrapper(FixedValueTranslation(value)).WrappedWith("'", "'");
                return(true);

            case NetStandardTypeCode.DateTime:
                if (!TryTranslateDefault <DateTime>(constant, out translation))
                {
                    translation = new DateTimeConstantTranslation(constant);
                }

                return(true);

            case NetStandardTypeCode.DBNull:
                translation = FixedValueTranslation("DBNull.Value", constant.Type);
                return(true);

            case NetStandardTypeCode.Decimal:
                translation = GetDecimalTranslation(constant);
                return(true);

            case NetStandardTypeCode.Double:
                translation = GetDoubleTranslation(constant);
                return(true);

            case NetStandardTypeCode.Int64:
                translation = new TranslationWrapper(FixedValueTranslation(constant)).WithSuffix("L");
                return(true);

            case NetStandardTypeCode.Int32:
                translation = FixedValueTranslation(constant);
                return(true);

            case NetStandardTypeCode.Object:
                if (TryGetTypeTranslation(constant, context, out translation) ||
                    LambdaConstantTranslation.TryCreate(constant, context, out translation) ||
                    TryGetRegexTranslation(constant, out translation) ||
                    TryTranslateDefault <Guid>(constant, out translation) ||
                    TimeSpanConstantTranslation.TryCreate(constant, out translation))
                {
                    return(true);
                }

                break;

            case NetStandardTypeCode.Single:
                translation = GetFloatTranslation(constant);
                return(true);

            case NetStandardTypeCode.String:
                var stringValue = ((string)constant.Value).Replace("\0", @"\0");

                if (stringValue.IsComment())
                {
                    translation = FixedValueTranslation(stringValue, typeof(string), isTerminated: true);
                    return(true);
                }

                translation = FixedValueTranslation(stringValue.Replace("\"", "\\\""), typeof(string));
                translation = new TranslationWrapper(translation).WrappedWith("\"", "\"");

                return(true);
            }

            translation = null;
            return(false);
        }