diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0d08d2e3..addee5a0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  ## Unreleased
 
 * Scan for CSS custom variable uses and assignments.
+* Fix value of reflectToAttribute for polymer properties
 
 ## [2.2.2] - 2017-07-20
 
diff --git a/src/polymer/analyze-properties.ts b/src/polymer/analyze-properties.ts
index 212aa338..3034c496 100644
--- a/src/polymer/analyze-properties.ts
+++ b/src/polymer/analyze-properties.ts
@@ -119,7 +119,8 @@ export function analyzeProperties(
             prop.readOnly = !!astValue.expressionToValue(propertyArg.value);
             break;
           case 'reflectToAttribute':
-            prop.reflectToAttribute = !!astValue.expressionToValue(propertyArg);
+            prop.reflectToAttribute =
+                !!astValue.expressionToValue(propertyArg.value);
             break;
           case 'computed':
             isComputed = true;
diff --git a/src/test/polymer/polymer-element_test.ts b/src/test/polymer/polymer-element_test.ts
index 32f5588c..80815e0b 100644
--- a/src/test/polymer/polymer-element_test.ts
+++ b/src/test/polymer/polymer-element_test.ts
@@ -41,25 +41,34 @@ suite('PolymerElement', () => {
       superClass: element.superClass && element.superClass.identifier,
       tagName: element.tagName,
       description: element.description,
-      properties:
-          Array.from(element.properties.values()).map((p) => ({
-                                                        name: p.name,
-                                                        inheritedFrom:
-                                                            p.inheritedFrom,
-                                                      })),
+      properties: Array.from(element.properties.values()).map((p) => {
+        const prop: {
+          name: string,
+          inheritedFrom?: string,
+          reflectToAttribute?: boolean,
+          readOnly?: boolean,
+          default?: string
+        } = {name: p.name, inheritedFrom: p.inheritedFrom};
+        p.reflectToAttribute &&
+            (prop.reflectToAttribute = p.reflectToAttribute);
+        p.readOnly && (prop.readOnly = p.readOnly);
+        p.default && (prop.default = p.default);
+        return prop;
+      }),
       attributes: Array.from(element.attributes.values()).map((a) => ({
                                                                 name: a.name,
                                                               })),
-      methods: Array.from(element.methods.values())
-                   .map((m) => ({
-                          name: m.name,
-                          params: m.params, return: m.return,
-                          inheritedFrom: m.inheritedFrom
-                        })),
+      methods: Array.from(element.methods.values()).map((m) => ({
+                                                          name: m.name,
+                                                          params: m.params,
+                                                          return: m.return,
+                                                          inheritedFrom:
+                                                              m.inheritedFrom
+                                                        })),
     };
   }
 
-  test('Scans and resolves base and sub-class', async() => {
+  test('Scans and resolves base and sub-class', async () => {
     const elements = await getElements('test-element-3.js');
     const elementData = Array.from(elements).map(getTestProps);
     assert.deepEqual(elementData, [
@@ -105,7 +114,31 @@ suite('PolymerElement', () => {
     ]);
   });
 
-  test('Elements inherit from mixins and base classes', async() => {
+  test('Computes correct property information', async () => {
+    const elements = await getElements('test-element-17.js');
+    const elementData = Array.from(elements).map(getTestProps);
+    assert.deepEqual(elementData, [
+      {
+        tagName: undefined,
+        className: 'BaseElement',
+        superClass: 'Polymer.Element',
+        description: '',
+        properties: [{
+          name: 'foo',
+          inheritedFrom: undefined,
+          reflectToAttribute: true,
+          readOnly: true,
+          default: '"foo"'
+        }],
+        attributes: [{
+          name: 'foo',
+        }],
+        methods: [],
+      },
+    ]);
+  });
+
+  test('Elements inherit from mixins and base classes', async () => {
     const elements = await getElements('test-element-7.js');
     const elementData = Array.from(elements).map(getTestProps);
     assert.deepEqual(elementData, [
@@ -134,7 +167,8 @@ suite('PolymerElement', () => {
         ],
         methods: [{
           name: 'customMethodOnBaseElement',
-          params: [], return: undefined,
+          params: [],
+          return: undefined,
           inheritedFrom: undefined
         }],
       },
@@ -185,17 +219,20 @@ suite('PolymerElement', () => {
         methods: [
           {
             name: 'customMethodOnBaseElement',
-            params: [], return: undefined,
+            params: [],
+            return: undefined,
             inheritedFrom: 'BaseElement'
           },
           {
             name: 'customMethodOnMixin',
-            params: [], return: undefined,
+            params: [],
+            return: undefined,
             inheritedFrom: 'Mixin'
           },
           {
             name: 'customMethodOnSubElement',
-            params: [], return: undefined,
+            params: [],
+            return: undefined,
             inheritedFrom: undefined
           },
         ],
@@ -212,14 +249,14 @@ suite('PolymerElement', () => {
       return [...elements][0]!;
     }
 
-    test('Elements with only one doc comment have no warning', async() => {
+    test('Elements with only one doc comment have no warning', async () => {
       const element = await getElement('test-element-14.html');
       const warning = element.warnings.find(
           (w: Warning) => w.code === 'multiple-doc-comments');
       assert.isUndefined(warning);
     });
 
-    test('Elements with more than one doc comment have warning', async() => {
+    test('Elements with more than one doc comment have warning', async () => {
       const element = await getElement('test-element-15.html');
       const warning = element.warnings.find(
           (w: Warning) => w.code === 'multiple-doc-comments')!;
diff --git a/src/test/static/polymer2/test-element-17.js b/src/test/static/polymer2/test-element-17.js
new file mode 100644
index 00000000..16cc4a7e
--- /dev/null
+++ b/src/test/static/polymer2/test-element-17.js
@@ -0,0 +1,18 @@
+/**
+ * @customElement
+ * @polymer
+ * @extends Polymer.Element
+ */
+class BaseElement extends Polymer.Element {
+  static get properties() {
+    return {
+      foo: {
+        notify: true,
+        type: String,
+        reflectToAttribute: true,
+        readOnly: true,
+        value: 'foo'
+      },
+    };
+  }
+}